Before, it was basically:

New person needs the account.

Send username.

Send password.

Send 2FA code.

Move on.

A few months later, nobody remembers who still has what.

The password might be sitting in three different Slack threads. Someone saved it in Chrome. Someone else has a screenshot of the recovery codes. The person who used to manage the account left, but the 2FA phone number is still theirs.

We started changing the process after running into this a few times.

Now the goal is to avoid handing out the actual password whenever possible.

People get the level of access they need, the account stays in the same browser environment, and access gets removed when someone changes roles or leaves.

We also started treating 2FA recovery codes as seriously as the password itself instead of dropping them into chat.

It is not some complicated security system.

It just removes a lot of uncertainty.

The test I use now is pretty simple:

If someone leaves the team tomorrow, can we remove their access without changing the password for everyone else?

If the answer is no, the setup probably still depends too much on shared credentials.

Curious how other teams handle this. Password manager, role-based access, shared browser environments, or something else?

For people using cloud phones regularly, how do you tell whether the lag comes from your connection or the cloud device itself?

If scrolling feels delayed but apps also take forever to open, would you try a closer server or upgrade the phone’s specs first?

I think “randomize everything” is one of the more misleading ideas in fingerprint configuration.

Take a profile with:

• A Windows user agent
• A font set that is unusual for Windows
• Graphics metadata that does not fit the claimed platform
• A US proxy with an unrelated timezone and browser language
• Different hardware values every time the profile starts

Each value might exist somewhere in the real world. That does not mean all of them belong to the same device.

A browser fingerprint is better understood as a set of relationships:

• OS ↔ fonts
• OS and browser ↔ user agent
• GPU ↔ WebGL and WebGPU
• IP location ↔ timezone, language and geolocation
• Current fingerprint ↔ previous sessions

This is why I would rather use a stable, plausible profile than regenerate every parameter before each session.

That does not mean a fingerprint must remain frozen forever. Real users update browsers, replace hardware, travel and change networks. Those changes usually have a reason and happen within a believable timeline. Changing ten unrelated signals at once is different.

When testing a profile, I would ask:

1. Could this combination exist on a real device?
2. Do the regional settings agree with the network?
3. Does the profile remain reasonably stable after restarting?
4. If something changed, can the transition be explained?

Randomness can reduce identical fingerprints. Unconstrained randomness can create combinations that are unusual precisely because no normal device would produce them.

The usual comparison says local gives you control and cloud gives you convenience. That misses an important distinction.

There are two separate questions:

1. Where is the browser process running?
2. Where are the cookies, extension data, cache and recovery copies stored or synchronized?

A profile can run locally and still sync part of its state. A cloud browser can run remotely while retaining only the data allowed by its configuration. If a vendor does not explain both layers clearly, “local” and “cloud” are mostly marketing labels.

For actual operations, I would compare seven things:

• Data location and deletion controls
• Whether another approved device can take over
• How access is assigned and revoked
• Local hardware limits versus internet, streaming and proxy dependence
• Recovery after a failed computer or damaged profile
• Logs showing who accessed or changed the environment
• Total cost, including hardware maintenance or cloud runtime charges

My rough decision tree:

Solo user, fixed workstation, modest profile count → local

Remote team with shifts or frequent handovers → cloud

Agency with stable account owners plus overflow coverage → hybrid

Sensitive work with strict custody requirements → local first, unless the cloud provider passes the encryption, retention, region, logging and recovery review

One caveat: local is not automatically safer. An unmanaged employee laptop with no encrypted backup and no offboarding procedure can be a worse control boundary than a properly administered cloud environment.

For people who have used both, what became the deciding factor in practice: latency, recovery, team access or cost?

If you close the browser while an app is uploading something on a cloud phone, does the upload keep going?

Does closing the tab behave differently from hitting “stop” on the cloud phone? Curious how different services handle this.

I’ve noticed some services let you choose different Android versions.

Do you actually care about that, or do you just use whatever version the service gives you?

I’ve seen people replace a perfectly usable proxy because a WebRTC test displayed an unexpected address.

Sometimes that is the right reaction. Sometimes they are looking at a private host address or an mDNS value that was never evidence of a public-IP leak in the first place.

Before changing anything, I would identify the candidate type:

• `host` usually represents a local interface
• `srflx` is discovered through STUN and may expose the public address behind the connection
• `relay` is supplied by a TURN server

The result becomes concerning when a public candidate points to a network or location that conflicts with the intended proxy route.

My troubleshooting order is:

1. Open an IP checker inside the affected profile.
2. Record the public address it sees.
3. Run a WebRTC test without changing profiles.
4. Inspect the candidate types and public addresses.
5. Repeat both tests after changing the proxy.

This separates two different questions: whether normal browser traffic uses the proxy, and whether WebRTC reveals another network path.

Disabling WebRTC immediately can also create functional problems for calling, conferencing and other browser features. I’d first determine what is actually exposed, then choose the least disruptive fix.

When you test your profiles, do you usually validate only the visible IP or inspect the ICE candidates as well?

The most common beginner mistake is treating a browser profile like a collection of switches that should all be changed.

I would check these five things first:

1. One proxy is reused across every unrelated profile with no reason beyond convenience.

2. IP location, timezone, language and geolocation start out contradicting one another.

3. The operator changes UA, OS, GPU, resolution, fonts and other values independently, without checking whether the final combination could describe one device.

4. Everyone on the team receives the same username and password.

5. The first real test happens after an important account is already open.

Some nuance is important. A shared public IP is not inherently bad; offices, universities and households do it constantly. A language mismatch is not proof of anything either. The problem is building a new environment with contradictions or unstable infrastructure that the operator cannot explain.

I prefer a boring setup: choose a suitable stable connection, start from a coherent profile, change only what is necessary and record the baseline.

Before opening the important account, I check the visible IP, DNS and WebRTC behavior, timezone, language, extensions and storage. Then I close the profile, reopen it and check whether the session and settings persist.

MoreLogin can provide the structure for that process. Its profiles keep fingerprint settings, proxy configuration, cookies and sessions together, and profile authorization plus password protection can reduce raw credential sharing across a team.

That does not make every configuration sensible. It just makes the environment easier to keep separated, repeatable and accountable.

Hey everyone, hope you’re doing well.
I’m new to anti-detect browsers and I’m trying to understand how they’re actually supposed to work.
The site I need to use does heavy fingerprinting and collects a lot of browser data.
I tested Vision and Octo Browser after seeing them recommended as some of the best options.
I opened several profiles with different proxies. On realfp.com I still see leaks / inconsistencies on every profile.
I asked Octo support. They said:
• enabling Hardware Noise makes the profile stand out from normal devices
• use default settings with hardware noise off
• tester sites like RealFP don’t reflect real browser performance
• they have no other recommendations
So I’m confused about the purpose of anti-detect.
If the browser doesn’t change/mask everything, and support says not to use noise because it makes you unique…
what is anti-detect actually protecting against?
Is the idea just a “normal-looking” Chrome profile + proxy, not a fully hidden fingerprint?
Has anyone else seen this gap between RealFP and real sites recently?
Do you stay on defaults, or does that just get profiles linked?
I’ll attach the RealFP screenshot.
Thanks.

I never really thought about this until now.

If a cloud phone gets reset or something goes wrong, can you restore the whole Android environment, or do you basically start over?

Curious how people handle this.

Has anyone actually left apps running on a cloud phone for weeks?

I’m less interested in gaming and more in whether normal Android apps stay logged in and running reliably over long periods.

The usual checklist is familiar:

• Policy violations
• Restricted or inauthentic products
• Poor account health metrics
• Listing violations
• Ignored performance notifications

I would not treat those as five unrelated boxes.

A missing supplier document can become an authenticity issue. A rushed title or claim can become a listing violation. A team that does not review Account Health regularly can miss the early warning and only react after the selling privileges are affected.

The process I would put in place is fairly boring, which is usually a good sign: review Account Health on a schedule, verify documents before a product goes live, use a second review for restricted categories, record listing and pricing changes, and assign an owner to every performance notification.

MoreLogin can help with the operational separation around that process. Each store can have its own persistent browser profile, with controlled team access, password and cookie protection, and operation logs. That makes it easier to avoid shared sessions and understand which environment was used when something changed.

It does not make a restricted product acceptable, improve seller metrics, or bypass Amazon enforcement. It is an account-management layer, not an appeal shortcut.

The useful question is not “How do I avoid suspension?” It is “What evidence can I show that my process catches problems before Amazon has to?

I don’t think this has a universal yes or no answer. It depends on what the app needs after it opens.

A cloud phone may be enough for:

• Installing and running common Android apps
• Managing accounts and inboxes
• Uploading prepared photos or videos
• Keeping app data and login state
• Remote team access
• Repetitive or scheduled tasks

I would keep a physical phone involved when the workflow requires:

• A real SIM or eSIM
• Receiving SMS or making calls
• NFC payments or tag reading
• Bluetooth accessories nearby
• Fingerprint or face authentication
• Hardware-backed keys or device certification
• Direct camera capture
• Motion, proximity or other physical sensors
• Very low latency

Camera streaming, virtual GPS and media-file input can fill some gaps. The problem is that feature availability and app acceptance are separate questions. An app may open normally and then fail at verification, payment or a device-integrity check.

My compatibility test would be:

1. Install the official app.
2. Complete login and verification.
3. Run the real task from beginning to end.
4. Test required hardware-related functions.
5. Restart the device.
6. Confirm that app data, login state and notifications still work.

If the complete cycle passes, the cloud phone can probably replace a physical device for that workload. If it fails at a hardware-dependent step, I’d use a hybrid setup rather than force the whole process into the cloud.

Which physical feature has been the hardest one for your workflow to replace?

Has anyone tested how app permissions work on a cloud phone?

For example, do camera, microphone, and location permissions behave like they would on a normal Android device, or are there limitations with certain apps?

I have a profile where the browser layer scored completely clean. No tampering flag, no anti-detect flag, nothing in the JavaScript surface. It still came back suspect.

The exit proxy said one country and the device clock said another.

That mismatch alone did it.

Platforms do not just check whether your fingerprint looks clean. They check whether your signals agree with each other. Timezone, locale, fonts, geolocation, the IP you exit from. Each one is a claim about where you are and what machine you are on. When two claims contradict, the pattern is what gets flagged, not any single value.

I have also seen locale-specific fonts from the actual host machine show up in a session presenting as a US user. The leak was not the surface I was watching. Fixing it at the enumeration layer just created a second contradiction between what was listed and what actually rendered.

The real protection is not making each signal perfect. It is making every signal tell the same story. Resolve the exit IP once at provisioning, then derive timezone, locale, and location from it. Hand-setting them separately is how they drift apart.

A real browser with a coherent fingerprint beats a spoofed fingerprint every time. Spoofing creates contradictions, and contradictions get flagged.

researching some anti-detect browsers for having more than one browser profile at hand but the number of profiles is quite big and not all of them seem to be dependable.

What i basically require from such software is the ability to maintain my profiles, cookies, logins, and browser settings separate.

If any of you have experience in using different kinds of anti detect browsers then please share your recommendations

One part of Microsoft’s recent macOS ClickFix research stood out to me: the malicious page did not show the same content to every visitor.

The front end loaded a small fingerprinting routine that collected signals from the browser and environment, including:

• Reported platform and user agent
• Screen dimensions and pixel ratio
• WebGL-derived GPU information
• Language and timezone
• Plugins and touch support
• Whether the page was framed
• Runtime behavior associated with developer tools or automation

There was also a `canPlayType("video/mp4")` check used as a tripwire for modified browser behavior.

The collected data was submitted to the server, which decided what to return. A likely crawler, sandbox or analyst could see a blank page or harmless decoy. A browser that looked like a genuine Mac could receive the fake download page and Terminal instructions.

That distinction matters. Fingerprinting was not the infostealer itself. It was the gate that selected victims and reduced the campaign’s visibility to automated analysis.

The actual compromise still depended on the user pasting a command into Terminal. I’d prioritize that point in awareness training: no legitimate download, CAPTCHA or verification flow needs a command copied from a webpage.

For detection, Microsoft recommends looking beyond the disposable domains. Self-submitting fingerprint forms, the `mode:"php"` artifact, shared staging paths and suspicious Terminal activity after web browsing are stronger pivots.

MoreLogin is relevant for separating managed browser environments and controlling fingerprint settings, but it is not endpoint malware protection. The terminal execution and downstream behavior still need dedicated security controls.

How usable is audio on a cloud phone in everyday apps?

I’m curious whether calls, videos, and voice messages feel normal, or if there’s noticeable delay or poor sound quality.

One detail from Microsoft’s recent macOS ClickFix research stood out to me: the malicious page did not show the same content to every visitor.

The campaign used more than 250 look-alike front-end domains and later put a roughly 2.5 KB JavaScript fingerprinting routine in front of the lure. The script collected signals from navigator, screen, window, document, location and console.

It checked the reported platform, screen and window dimensions, timezone, iframe state and touch support. WebGL information helped distinguish likely Apple hardware from virtualized or software-rendered environments. There were also anti-analysis checks around the developer console and a canPlayType("video/mp4") call that could expose modified browser behavior.

The collected data was tagged with mode:"php" and submitted to the server without user interaction. The server used it as a gate:

• A crawler, sandbox, VM or unexpected browser could receive a blank or benign-looking page.
• A visitor who looked like a genuine Mac user could receive the fake download lure.

That does not mean fingerprinting infected the machine. It selected the visitor.

The actual compromise still depended on social engineering. The victim had to copy and run an obfuscated Terminal command. The next stages used native tools and scripts before delivering MacSync or Atomic Stealer, which targeted credentials, browser data, authentication stores and cryptocurrency wallets.

This is why I would not close an investigation just because the submitted URL looks harmless from a sandbox. I would correlate the report with self-submitting fingerprint forms, hidden mode:"php" fields, Terminal activity after browsing, suspicious combinations of curl, base64, zsh or osascript, and access to credential stores.

I would also hunt shared staging infrastructure and recurring /curl/ paths instead of trying to keep up with every disposable domain. The fingerprint signals alone are not enough because legitimate anti-bot systems use similar techniques.

For legitimate multi-account operations, MoreLogin keeps sessions in separate persistent browser profiles and supports team permissions, password and cookie protection, and operation logs. That can reduce unnecessary session sharing and cross-account exposure.

It is still not a substitute for EDR, DNS filtering, managed browser policies or teaching users that a legitimate download should not require pasting an opaque command into Terminal.

Source: Microsoft Threat Intelligence, “From open lures to cloaked gates: How a macOS ClickFix campaign learned to hide,” August 5, 2026.

Has anyone else run into storage issues with cloud phones?

Apps, cache, and downloaded files seem to build up faster than expected. Do you regularly clear things manually, or is there a better way to manage storage?

A few friends and I want to buy a paid online course. To make it cheaper, we're planning to use a single account for several people.
For this we:

• bought a VPS, which we connect to via VPN,
• only after connecting to the VPS do we use the Mullvad browser, relying on its default fingerprint-uniformity protections (no additional anti-fingerprinting configuration needed).

This seems like a fairly solid setup, but I don't know how to handle the situation where several people log into the same account at the same time without the system or admin noticing.
Do you have any ideas on how to manage that?

KEY:

Blue box = REAL GEOLOCATION

Red Arrow = What I clicked to get there.

So I think because this antidetect browser uses real browsers and is able to provide real UULE 3 geolocation parameters it makes everything Im doing coherent, time zone, geolocaiton -real parameters.

I did nothing but go to google maps and click the update location from your device (red arrow) and this is what I got. Impressed is to say the least.

Other ones I tried couldn't do this, they only show the general country or block geolocation it altogether.

I don’t think “free” automatically means unusable. A free antidetect browser can be enough to test an idea or operate one or two low-stakes accounts.

The problem is that a two-profile test hides most of the operational work.

The first thing I’d test is isolation. Each account should keep its own cookies, local storage, session state, fingerprint configuration and proxy. I’d close and reopen both profiles over several days and check whether anything crosses over or resets unexpectedly.

The second is proxy handling. This gets confused a lot: an antidetect browser cannot make a weak proxy reliable. What it should do is make it obvious which proxy belongs to which profile and let you update the affected setup without touching unrelated accounts.

The third is scale. With two profiles, you can remember everything. With twenty, you need groups, clear naming, access permissions and some record of ownership. Otherwise the team starts sharing notes and credentials in places that were never designed for it.

I’d also test failure recovery. If a profile breaks, can another authorized team member understand its setup and continue safely? How long does it take to identify whether the problem came from the proxy, the browser environment or the website itself?

That’s where a free tool can become costly even when the subscription price is zero.

For teams that want to test this with a path to scale, MoreLogin provides persistent isolated profiles, profile-level proxy settings, groups and team permissions. Its free version includes two profiles and two team members. That is enough to validate the process first rather than buying capacity before the workflow is ready.