Notification permissions as a quiet identifier
What your browser is quietly telling sites about permissions
Every time a page loads, it can ask your browser one simple question without you ever seeing a prompt: what’s the current permission state for notifications on this origin? The answer comes back as one of three words: default, granted, or denied. No popup, no click, no consent dialog. The site calls Notification.permission or navigator.permissions.query({name: "notifications"}) and gets a synchronous or near instant answer.
This matters because permission state isn’t just about notifications. The same query pattern works for geolocation, camera, microphone, clipboard read access, and a handful of other browser capabilities. Put those answers together and you get a small vector of yes/no/unset values that sits alongside everything else a fingerprinting script collects: screen resolution, installed fonts, WebGL renderer string, audio context fingerprint, timezone, language list. Notification permission is one entry in that vector. But it behaves differently from most of the others, and that difference is what makes it worth understanding if you run more than one browser profile.
I run proxy infrastructure and cloud phone farms for a living. I spend a fair amount of time testing anti-detect browsers against real detection stacks, not because any of them promise to make a profile undetectable, none of them do, and any vendor claiming otherwise is selling something, but because understanding which signals leak and why is the actual job. Notification permission state is one of the more overlooked ones. It doesn’t get the attention canvas fingerprinting or WebGL spoofing gets, partly because it feels minor, and partly because most fingerprinting writeups treat it as a footnote next to more dramatic signals. But it has a property the flashier signals lack. It’s persistent, it’s cheap to check, and it tends to get inherited wholesale when profiles are cloned from a template, which is exactly how most multi-accounting setups build new identities at scale.
The rest of this piece walks through why that persistence matters, where the state actually lives on disk, what a realistic leak looks like across cloned profiles, and what you can check on your own setup regardless of which anti-detect browser you’re running.
Why this signal doesn’t behave like canvas or WebGL noise
Most fingerprint randomization in anti-detect browsers works on rendering output. Canvas fingerprinting draws a hidden image to a canvas element and hashes the pixel data; anti-detect tools inject small amounts of noise into that pixel output so the hash comes out different on each profile. WebGL fingerprinting reads back renderer and vendor strings, or does something similar with rendered geometry, and again the countermeasure is to alter what gets rendered or reported. Audio context fingerprinting works the same way: perturb the waveform output slightly, get a different hash.
All of these are about intercepting an output at the moment it’s generated. The browser computes something. The injected patch changes the computation or the result, and the site sees a different value than it would on stock Chromium. Crucially, that patch can be applied consistently every time the page asks, because it’s just intercepting a function call and returning a modified result.
Permission state is stored, not computed on the fly. When a site asks for notification permission and the state is “granted,” that’s because at some earlier point the browser wrote “granted” for that origin into a permission store on disk. When a page asks navigator.permissions.query() today, the browser is reading back what it wrote before, not generating a fresh answer. You can’t inject noise into a read of a stored value the same way you inject noise into a canvas render. The permission system has to return the same answer every time for the same origin, otherwise the browser would be lying to the site about whether it can send notifications, and real notifications would silently break.
That distinction, computed noise versus stored state, is why permission fingerprinting gets missed. Most fingerprint injection scripts patch rendering APIs. Fewer of them touch the permission store, because touching it convincingly means managing a persistent database correctly across the life of a profile, not just intercepting a function call.
Where the state actually lives in the browser
In Chromium based browsers, which is what the overwhelming majority of anti-detect tools are built on, site permissions live in the profile’s own storage, separate from cookies and separate from local storage. You can see a human readable version of it by opening chrome://settings/content/notifications in any Chromium browser: there’s a list of sites that are allowed to send notifications and a list of sites that are blocked. That same list, plus equivalent lists for geolocation, camera, microphone, and other permission types, is stored in the profile’s preference and permission database files inside the user data directory for that profile.
This matters for one specific reason. It lives inside the profile folder, not inside the cookie jar. When you clear cookies and site data for a domain, either manually or through whatever cleanup routine your anti-detect tool runs between sessions, you are not necessarily touching the permission store. The two are adjacent but separate storage mechanisms, built for different purposes, cleared by different UI actions and different API calls.
Most anti-detect browsers expose a “clear cookies” or “reset profile” action. Fewer expose an equally visible “clear all site permissions” action, and even when they do, operators running bulk workflows frequently don’t include it in their reset script, because it’s not the thing that visibly breaks a login session when it’s stale. Cookies expiring or getting flagged is an obvious, immediate problem. A permission store that still says “granted” for a site you visited three profiles ago is invisible until someone specifically checks for it, which almost nobody does day to day.
The gap between clearing cookies and clearing permissions
This creates a specific and fairly common mismatch. A profile gets reset for reuse: cookies cleared, local storage wiped, cache emptied, maybe even a new canvas noise seed generated. By every visible signal, it looks brand new. But if the reset routine didn’t specifically touch the permission database, and many don’t, the permission store from the previous identity that used this profile folder is still sitting there.
The failure shows up in one of two directions. Either the “fresh” profile still carries granted or denied permissions for sites it was supposedly never on, a straightforward tell that this isn’t actually a first visit. Or the profile was built by cloning a golden template rather than resetting an old one, inheriting the template’s entire permission history on day one. The second case is more common in anti-detect workflows than the first, because cloning a configured template is the standard way to spin up new profiles at any real scale. Nobody builds fifty profiles by hand from a blank Chromium install; they build one clean template with the fingerprint config, extensions, and settings they want, then duplicate it.
The problem is that whatever permission state existed in the template at the moment of cloning gets duplicated too. If the person who built the template visited five test sites and clicked “allow” on notification prompts during setup, testing that things worked, every single profile cloned from that template now carries identical granted permissions for those same five origins, with no browsing history to explain how it got there. This is close to the default outcome of template based provisioning, unless someone deliberately strips the permission store before duplicating the profile. Not a hypothetical edge case.
Cross-profile leakage in anti-detect browsers
The cloning problem becomes a correlation problem the moment you have more than one profile derived from the same template. Detection systems that do cross-account clustering, the kind platforms use to link accounts back to a single operator despite different IPs, different cookies, and different fingerprints, are looking for exactly this kind of shared, low-entropy artifact. An identical set of granted notification origins across accounts that otherwise look unrelated is a strong correlating signal, arguably stronger than a lot of the fingerprint fields people worry about more. It’s not supposed to be identical at all. Two genuinely separate people, using separate browsers, do not organically end up with the exact same list of sites granted notification access, in the exact same order, with the exact same denied list underneath it.
This is worth sitting with for a second: fingerprint noise like canvas or audio hashing is meant to make profiles look different from each other so they don’t get linked by shared entropy. Permission state, if it’s inherited from a shared template without being scrubbed, does the opposite. It makes profiles look identical to each other on a dimension that real, independent users would never share. You end up with a signal that actively points back at a common origin. It’s not just present.
The severity depends on how many origins are in that shared list and how specific they are. A single shared “denied” entry for some generic ad network isn’t damning on its own. Permission blocklists for known ad domains are common enough across real installs that they don’t stand out much. But a shared granted entry for a niche site, especially one relevant to whatever the accounts are being used for, is a much sharper correlator, because the odds of that being a coincidence across independent users drop fast.
A worked example: three profiles, one giveaway
Here’s a concrete way to see this on your own machine, not to bypass anything, just to check whether your own provisioning process leaks in this specific way. Build three profiles in whatever anti-detect browser you use, the way you’d normally build them for real work: clone from your standard template, apply your usual fingerprint randomization, go through whatever warmup or setup routine you normally run.
Then, in each profile, open the developer console on a page and run something like:
navigator.permissions.query({name: "notifications"}).then(p => console.log(p.state))
Do this for notifications, geolocation, and camera on the same handful of test origins across all three profiles. Also check chrome://settings/content/notifications directly to see the full allowed and blocked lists, not just the state for one origin.
What you’re looking for is whether the lists match across the three “independent” profiles. If all three show an identical set of granted or blocked origins that trace back to sites visited during template setup rather than during this profile’s own browsing history, that’s the leak. It means your provisioning pipeline is baking a shared fingerprint element into every profile it produces, and it’s been doing that the whole time, invisibly, because nobody checks the permission store the way they check for cookie leakage or IP consistency.
If you find this, the fix isn’t complicated: strip the permission database from the template before cloning, or run a reset step that specifically clears chrome://settings/content state, not just cookies and cache, before a profile goes into rotation. But you have to know to look first, which is the actual point of running this test.
Why default-deny across the board is not a fix
Once operators become aware of this, a common overreaction is to force every profile’s notification permission to “denied” for every origin, either through browser policy or by scripting a blanket denial during provisioning. It feels safe: nothing granted, nothing to leak, no risk of an accidental shared “allow” state giving anything away.
The problem is that a profile where literally every origin, forever, shows “denied” is its own kind of unnatural pattern. Real browsing doesn’t produce a clean, universal denial. Most people, when a notification prompt pops up, do one of three things depending on the site and their mood that day: dismiss it without deciding (which leaves the state at “default,” not “denied”), click deny because the prompt is annoying, or click allow because they actually want the notifications, news sites and messaging apps get allowed reasonably often in real usage. Over months of normal browsing, a real profile accumulates a messy, inconsistent mix of default, denied, and occasionally granted states across dozens of origins it has visited.
A profile that shows uniform denial across every single site it’s ever touched, with zero granted and zero left at default, doesn’t look like a cautious user. It looks like a script that set a policy at the browser level, rather than a person clicking through prompts one at a time. Detection systems that model expected permission distributions for real users can flag a profile that’s too clean in the same way they flag one that’s suspiciously identical to others. The base rate problem cuts both ways: identical-to-other-profiles is a tell, and unnaturally uniform-within-itself is also a tell. Neither extreme mimics how permission state actually accumulates when a human uses a browser over time.
Push subscription endpoints as a secondary identifier
Granted notification permission is just the start. Once a site has permission, it typically registers a service worker and calls PushManager.subscribe() to get a push subscription. That call returns an endpoint URL, and for Chrome and Chromium based browsers, that endpoint points at Google’s Firebase Cloud Messaging infrastructure and includes a subscription ID that’s effectively unique to that browser instance and that push registration.
This subscription ID is a much harder identifier than the permission state itself. It’s not just a three-value flag, it’s a long unique token tied to the underlying browser and, in some configurations, device level push registration infrastructure. If an anti-detect setup resets cookies and fingerprint noise between sessions but doesn’t tear down and regenerate the push subscription and the underlying keys it depends on, that subscription ID can persist across what’s supposed to be a completely fresh identity. On mobile and cloud phone setups specifically, this risk is higher. Notification permission there ties into a shared Google Play Services install rather than a fully isolated browser profile, and the install ID and push token layer sits below the browser profile boundary entirely, untouched by browser-level resets.
The practical implication is that “granted” is a gateway to a much more specific and durable identifier sitting one layer deeper. It’s not just a flag to hide. If your workflow doesn’t need push notifications at all for the accounts you’re managing, the safest posture is making sure permission requests never get answered with “allow” in the first place during setup. That way, no subscription ever gets created to leak later.
Site-specific permission histories and pattern matching
Large platforms doing account risk scoring don’t look at notification permission state in isolation. They fold it into a broader signal set alongside dozens of other fingerprint fields, and the specific pattern they’re often modeling isn’t just “what’s the current state” but “how did this state come to exist.” Timing is part of that. A permission prompt that gets answered within a few hundred milliseconds of the page rendering looks different from one answered after a few seconds, because the first pattern is consistent with a script auto-clicking through a dialog during automated setup, while the second is consistent with a person actually reading the prompt or getting distracted before responding.
This kind of timing analysis isn’t unique to permission prompts. It shows up in how detection systems treat form fills and click patterns generally, but permission prompts are a particularly clean signal for it, because there’s exactly one moment where the decision gets made and it’s trivially timestamped. If a provisioning script clicks through dozens of profiles’ notification prompts in a batch job, each click landing within the same narrow millisecond window relative to page load, that’s a detectable rhythm even if every other fingerprint field on those profiles looks perfectly distinct.
Combined with the origin-list correlation problem from earlier, this means permission handling gets scrutinized on at least three axes at once: whether the current state matches what an organic browsing history would produce, whether that state is suspiciously identical across profiles that are supposed to be unrelated, and whether the timing of how the state was set looks human or scripted. None of these checks require anything exotic on the platform’s side. They’re cheap to run against existing telemetry that most sites already collect for other reasons. That’s part of why this signal is worth taking seriously even though it rarely gets discussed. The detection side of it is neither expensive nor experimental.
How different anti-detect browsers approach this, broadly
I want to be careful here. I haven’t run a controlled side by side comparison of exactly how Multilogin, GoLogin, Kameleo, AdsPower, and Dolphin Anty each handle permission store resets, and I’m not going to invent scores or rankings I don’t actually have. What I can talk about is the architectural split that determines how this problem tends to get handled, because it’s structural rather than vendor specific.
Broadly, anti-detect tools split into two architectures. Cloud-profile tools run the actual browser profile and its storage on the vendor’s infrastructure, and you connect to it remotely or through a local client. Local-profile tools keep the Chromium user-data-dir on your own machine, with the tool acting mostly as a fingerprint injection and profile management layer on top of it. Multilogin and GoLogin both popularized cloud-based profile handling as an option; Kameleo, AdsPower, and Dolphin Anty lean more toward local profile storage with cloud sync for configuration, though most of these tools offer some mix of both depending on plan and setup.
The practical difference for this specific issue is where the permission database physically lives and who’s responsible for clearing it. On a cloud profile, a “reset” action triggered from the vendor’s dashboard can, in principle, tear down the entire profile storage including the permission database in one step, because the vendor controls the whole storage layer server side. On a local profile, the reset is only as thorough as whatever script or button the tool provides. If that reset doesn’t specifically target chrome://settings/content state alongside cookies, the permission store survives untouched, sitting in a SQLite file in the profile folder regardless of which vendor’s branding is on the browser window.
Either architecture can be done well or done sloppily. Neither category is inherently safer. Operators using local-profile tools just carry more of the responsibility themselves for making sure permission state actually gets cleared, because there’s no server side reset acting as a backstop.
How to check your own setup right now
This is a diagnostic you can run on your own profiles today, and it’s the same test outlined earlier applied as a standing habit rather than a one-off. Pick a profile that your tool claims is fresh, one that was just created or just reset, and before doing any browsing in it, open chrome://settings/content/notifications and look at both the allowed and blocked lists. A genuinely fresh profile should show both lists empty. If either list already has entries, your reset or clone process isn’t touching the permission store, full stop.
Next, run the same navigator.permissions.query() check from the worked example across a handful of profiles built from the same template, for notifications, geolocation, camera, and microphone. Log the results somewhere simple, a spreadsheet is fine. If two or more profiles that are supposed to be unrelated return identical non-default states for the same origins, you’ve confirmed the cross-profile leakage described earlier, and it’s worth tracing back to whichever step in your provisioning process is responsible, usually the template itself.
Finally, if any of your workflows depend on notification permission being granted for legitimate reasons, check whether a push subscription actually got created for each profile, and whether the subscription details differ meaningfully between profiles rather than showing signs of a shared underlying registration. This is a heavier check and not something most workflows need to run routinely, but it’s worth doing once to understand what your specific tool and setup actually produces, rather than assuming.
None of this is about defeating a platform’s detection system or working around its terms of service. It’s an audit of your own infrastructure, understanding what it’s actually doing versus what you assumed it was doing. Those are frequently different things, and the gap tends to be invisible until you specifically go looking for it.
Failure modes I’ve seen in real multi-profile operations
The most common pattern I’ve run into is exactly the golden template problem described earlier. It usually starts innocently. Someone builds a template profile, configures the fingerprint settings, installs the extensions they need, and while testing that everything works, visits a handful of real sites and clicks through whatever prompts appear, including notification permission prompts, because clicking “allow” is the fastest way to confirm notifications are working before moving on. That template then gets cloned into dozens or hundreds of working profiles over the following weeks, and every one of them quietly carries that same handful of granted origins from day one.
A second pattern shows up in cloud phone and mobile-adjacent setups more than pure desktop browser workflows: batch provisioning that reuses a base device image or a shared Google account layer underneath multiple “separate” profiles. Even when the browser-level fingerprint and cookies are properly isolated per profile, the underlying push registration infrastructure sitting below the browser, tied to the device or account layer rather than the browser profile, doesn’t get reset by anything the browser-level tooling touches. This is a harder leak to catch, because it doesn’t show up in the browser’s own permission settings page at all. It requires checking the push subscription layer directly.
A third pattern is more about operator habit than tooling: manually setting up a batch of new profiles by hand, clicking through the same sequence of setup steps on each one in quick succession, including answering the same permission prompts in the same order within seconds of each other. Even with a properly clean template and no shared push registration, this produces the timing correlation problem from earlier: dozens of profiles with permission decisions clustered in the same narrow time window. The human doing the setup work was moving through a checklist, not genuinely using each browser independently.
What actually reduces this exposure
The fixes here are unglamorous and mostly about process discipline rather than new tooling. Before a template gets cloned into working profiles, strip its permission database, not just its cookies. If your anti-detect tool doesn’t expose a specific “clear site permissions” action separate from “clear cookies,” check whether it has a raw file-level reset option, or manually clear chrome://settings/content for the template before duplicating it. This is a one-time step per template, not an ongoing burden, and it closes the most common leak by a wide margin.
Second, treat permission prompts during setup and warmup routines as something to avoid triggering at all rather than something to answer. If a setup script visits test sites to confirm configuration, don’t let it interact with permission dialogs, dismiss or ignore them rather than clicking through, so no state gets written to the store in the first place. A profile with no permission history at all is far less distinctive than one with a small, specific, and shared set of grants.
Third, if you’re batch-provisioning by hand, introduce some actual variance in timing between profiles rather than moving through a checklist at a fixed pace. This sounds trivial. But it addresses the timing correlation problem directly, and it’s free.
Fourth, periodically audit a sample of your active profiles the way described in the previous section, not just new ones. Templates and provisioning scripts drift over time as people patch them or add new setup steps, and a check that passed six months ago isn’t a guarantee about what the pipeline produces today.
None of this makes a profile undetectable. Treating it as a checklist that guarantees safety would be the wrong takeaway. It’s one signal among the many that detection systems weigh, and reducing it just removes one contributor to risk, not the risk itself.
What to change this week
If you take one thing from this, it’s that permission state deserves the same routine attention you already give cookies, IP consistency, and canvas noise. Right now, it almost certainly isn’t getting that attention in most multi-profile workflows, including ones running on well regarded anti-detect browsers. The tooling gives you the knobs to fix this: clearing site data, resetting profiles, isolating storage. But none of the major platforms in this space make permission store hygiene the default, visible, one-click action that cookie clearing is. That gap between what’s possible and what actually happens by default is where the leak lives.
The audit takes twenty minutes: open the settings page on a supposedly fresh profile, run the console check across a few clones of the same template, and see what comes back. If the lists are clean, you’ve confirmed something useful about your process. If they’re not, you now know exactly which step in your provisioning pipeline needs a fix, and it’s a cheap one to make.
This kind of unglamorous, structural signal is a lot of what actually separates a careful multi-profile setup from a sloppy one, more than any single vendor’s marketing claims about fingerprint randomization. No anti-detect browser, however well built, removes the need to understand what your own profiles are actually storing and why.
If you want more of this kind of hands-on, no-hype breakdown of how anti-detect browsers actually behave under real testing, check out the rest of the site at Anti-Detect Review.
Get new guides and videos first — join the Telegram channel.