One Workstation Or Several: Separating Physical Machines For Fleet Work
An antidetect browser makes a strong promise on the screen: forty profiles, forty separate devices, each with its own fingerprint and its own cookies. It’s easy to take that literally and conclude that the computer underneath no longer matters. One good laptop, forty accounts, done.
The profiles really are separate in the ways the browser controls. What they share is everything the browser doesn’t control, which is the machine itself and the person sitting at it. The graphics card that actually draws every page. The fonts installed on the system. The clipboard. The downloads folder. The network the machine falls back to when a proxy drops. The operator’s own browser, open in the next window.
For many operators, one machine is genuinely enough. For some, a second or third machine is the cheapest risk reduction available. The difference comes down to what you’re separating and why, and this piece walks through both sides using local hardware, the computers on your own desk. Running profiles on rented servers is a separate subject with its own trade-offs.
What a profile isolates and what it doesn’t
An antidetect profile is a browser with its own storage and its own reported fingerprint. Cookies, local storage, cache and history belong to the profile and don’t leak into its neighbours. The values a page reads, such as the user agent, screen size, time zone, language, hardware concurrency and the graphics renderer string, are set by the profile, often independently of the real machine.
That covers the most common linking paths, and it’s why antidetect browsers work at all.
What the profile can’t change is the physical work the machine does. When a page draws a canvas or runs a WebGL scene, the real graphics hardware and driver do the drawing. Antidetect tools handle this with masking or noise, adjusting what the page reads back, but the underlying rendering comes from the same GPU for every profile. When a page measures text, the real installed fonts do the rendering, even if the reported font list is trimmed. When a page measures timing, it’s the real CPU doing the work.
Outside the browser, the profile has no reach at all. The operating system’s clipboard is shared by every window on the machine. So is the file system. So are the network interfaces, the system clock and every other application running alongside.
None of this means the profiles are weak. It means the host is a shared layer under every profile, and your job is deciding how much sharing that layer can safely carry for the accounts you run.
The graphics card underneath every profile
Of the hardware signals, graphics is the one that most clearly ties profiles on one machine together.
Canvas and WebGL fingerprinting work because different GPUs, drivers and operating systems produce slightly different pixels for the same drawing. An antidetect profile can report a different renderer string, pretending to be a different card, and can add noise to readbacks so each profile’s canvas hash differs. That’s the standard approach, and for many detection setups it’s sufficient.
But the noise is applied on top of the real output. A detection system that renders many different test scenes, or that checks how rendering behaves rather than just hashing a result, can in principle notice that several profiles share an underlying rendering behaviour even when their hashes differ. How many platforms go that deep isn’t public. Vendors and researchers argue about it constantly, and the details change.
There’s also a plausibility question. A profile that reports a high-end discrete graphics card while rendering at the speed and with the quirks of an integrated laptop chip is describing a device that doesn’t exist. Better antidetect tools pick renderer values that fit the real hardware for exactly this reason, which means profiles on one machine tend to claim similar graphics families.
So one machine gives every profile the same graphics foundation. For most social and commerce work that’s acceptable, because the reported values are what most checks read. For accounts where you want the strongest possible separation, different physical hardware gives each group of profiles genuinely different rendering, which no amount of masking fully replicates.
Fonts and the host system
Fonts are the second host-level signal that crosses profile walls, and they’re easier to reason about than graphics.
A web page can’t read your font list directly. It infers it by trying to render text in many fonts and measuring the results. If a font is installed, the text renders in it and the measurements change. So the real set of installed fonts on the machine determines which fonts are available to every profile.
Antidetect tools handle this by restricting which fonts a profile will use, so its apparent list matches the operating system it claims. That works well when the claimed system and the real one are close, for example a Windows profile on a Windows machine. It gets harder when they’re far apart. A profile claiming macOS on a Windows host can hide the Windows fonts. It still can’t render in Mac system fonts it doesn’t actually have, so some text will fall back to substitutes whose measurements don’t match a real Mac.
Installed software adds fonts quietly. Office suites, design tools, games and language packs all install their own. If the host has an unusual collection, profiles that don’t restrict fonts tightly may show it.
The practical upshot is that profiles on one machine should mostly claim the same operating system family as the host. If you need believable personas on a different system, the most reliable route is a real machine running that system. A second machine running macOS is a better base for Mac personas than a Windows workstation pretending.
Keep the host’s font collection plain, too. A workstation used for design work, with hundreds of extra fonts, is a poor base for fleet profiles.
The clipboard, the most human leak
The clipboard is shared by every window on a machine, and it carries the leaks that come from the operator rather than from the hardware.
Here’s how it goes wrong. You copy a caption from one account’s draft to reuse its structure, switch to another profile and paste it with a small edit. You copy a link from one profile and paste it into another. You copy an email address or phone number from the fleet spreadsheet and paste it into the wrong profile’s sign-up form. In every case the content, not the fingerprint, links two accounts, and the clipboard was the path.
Browsers also have a clipboard API that pages can use to read clipboard contents, but reading generally requires a user gesture or explicit permission, so a page silently lifting whatever you last copied isn’t the typical risk. The typical risk is you pasting something where it doesn’t belong.
Clipboard managers make it worse. They keep a history of everything copied, sometimes synced to the cloud and across devices. A clipboard history that holds snippets from forty accounts, available in every window, is a standing invitation to paste the wrong thing.
The mitigation on one machine is discipline. No clipboard manager on the fleet machine. Clear the clipboard when switching between unrelated accounts. Keep reusable content in a system that’s labelled by account, and copy from it deliberately.
Separate machines help mainly by adding friction. If personal work and fleet work sit on different computers, you can’t paste your personal email into a fleet sign-up by accident, because it isn’t on that clipboard.
What files carry with them
The file system is shared by every profile on a machine, and files carry more than their visible content.
Images carry metadata. A photo taken on a phone may include the camera model, a timestamp and sometimes GPS coordinates in its EXIF data. Edited images may carry the editing software’s name and settings. Many platforms strip metadata on upload, but not all do, and some may read it before stripping it. If two accounts upload files that share metadata, or the same file, that’s a content link the fingerprint doesn’t touch.
Downloads accumulate. A shared downloads folder fills with files from every profile, and it’s easy to upload a file downloaded in one profile to a different account. File names can be revealing too. An image called client-a-banner-final.png uploaded by an account that’s supposed to be unrelated to client A tells its own story.
Documents carry author names and company fields from the office software’s settings. A PDF created on your workstation may name you as its author.
On one machine, the mitigations are organisation and stripping. Per-account folders instead of one shared downloads folder. A habit of removing metadata from images and documents before upload, with a tool you trust. Neutral file names. And never setting your real name in office software on the fleet machine.
Separate machines help when the separation is between clients or between personal and fleet work, because the files simply aren’t there to be picked up by mistake.
When the network falls back to the host
Every profile routes through its proxy until the proxy stops working. What happens next depends on the tool and the settings, and in the worst case, traffic goes out through the machine’s own connection.
Most antidetect browsers fail closed. If the proxy is unreachable, the profile refuses to load pages rather than falling back to direct access. But not every tool behaves this way in every situation, and other software on the machine may not respect proxy settings at all. A desktop app for a platform, an update service, a browser extension making its own requests: any of these can reach the internet directly through the host’s network.
On one machine, all of that direct traffic comes from the same home connection, which is the one address you most want kept away from the fleet. One slip, and a platform has an account connected to your real IP. If the same slip happens across several profiles, they’re connected to each other through it.
There are layers of defence. Test how your antidetect tool behaves when a proxy dies, by deliberately breaking one. Don’t install platform desktop apps on the fleet machine. At the network level, you can put the fleet machine on its own network segment and use firewall rules so it can only reach your proxy providers and nothing else. Then a fallback fails instead of leaking.
Separate machines make that network-level control easier. A dedicated fleet machine can sit behind strict rules that would be unbearable on your personal computer, because it has one job.
Your own browser in the next window
The single most common host-level leak in small operations is the operator’s personal browsing on the same computer, and there’s nothing technical about it.
Your personal browser is signed in to your personal accounts. It carries your real fingerprint, your real cookies and your home IP. If you log into a fleet account in your personal browser, even once, to check something quickly, that account now has a session from your real device and your real network. Platforms record that, and it doesn’t go away.
It goes the other way too. You log into a personal account inside a fleet profile because it was the window that was open. Now that profile, and whatever accounts share it, is connected to you.
On one machine, both of these are one click away all day. The discipline to avoid them has to hold every single time, including at the end of a long night when the personal browser is already open and the fleet profile would take ten seconds to launch.
This is the strongest argument for a separate machine, and it has nothing to do with fingerprints. A dedicated fleet computer, with nothing personal installed or signed in, turns a discipline problem into a physical one. You can’t click into the wrong world, because the wrong world isn’t on that machine.
If a second computer isn’t possible, at least use a separate operating system user account for fleet work, with no personal accounts signed in, and log out of it when you’re done.
Screens, monitors and the physical desk
The physical display is another host detail that profiles report around rather than replace.
A profile sets the screen resolution and pixel density that pages read. But the browser window still lives on a real monitor, and a few properties can reflect the real desk. Window position values tell a page where the window sits relative to the screen. On a multi-monitor setup, a window on the second screen can report positions that only make sense if there’s another display beside it. The available screen area, which excludes taskbars and docks, depends on how the real operating system lays out its interface.
Good antidetect tools keep these values consistent with the reported screen. Where they can slip is when the real setup is unusual. A profile claiming a 1920 by 1080 laptop screen, opened in a window stretched across two 4K monitors, may report window sizes larger than its own screen. A profile claiming a phone-sized screen on a desktop window is an obvious contradiction.
The practical habits are simple. Open fleet profiles on the primary monitor. Keep windows at sizes that fit inside the screen each profile claims. Avoid maximising a profile across displays. And pick reported screen sizes that are common for the device each profile describes.
This is also one of the quieter ways machines differ from each other. A laptop and a desktop with an external monitor present different physical desks. Profiles that live on one machine inherit that machine’s desk, which is one more reason to keep each profile on its home machine.
Desktop apps read more than browsers do
Browsers are sandboxed. A web page can’t read your MAC address, your disk serial number or the list of programs installed on your computer. Desktop applications usually can.
That matters when a platform has its own desktop app, or when you install software from a platform’s partners. Native apps can often collect hardware identifiers that no browser exposes, such as network adapter addresses, machine identifiers from the operating system and sometimes details of connected devices. If you run a platform’s desktop app for several accounts on one machine, those accounts share identifiers that no antidetect profile touches, because the profile isn’t involved at all.
Peripherals are a smaller version of the same thing. Browsers can list media devices, cameras and microphones, and after permission is granted they can see device labels. A distinctive webcam name showing up across several profiles is a shared detail. Bluetooth and USB access in browsers exist but require explicit permission, so they’re rarely a passive leak.
The rule for a shared fleet machine is to keep account work inside the browser profiles and keep platform desktop apps off it. If an account genuinely needs a desktop app, that account needs its own machine, or it belongs on a phone where device-level isolation is the whole point.
And think about what else is installed. Remote support tools, screen recorders and cloud sync clients all run with broad access to the system. None of them identify you to a platform directly, but each is another piece of software that can see everything the fleet does, which is worth a moment’s thought before installing.
When one machine is enough
With all of that said, plenty of operations run well on a single computer, and buying hardware you don’t need is a waste.
One machine is usually enough when you work alone, on one project or one client, with a modest number of profiles. When the host is dedicated to fleet work and doesn’t carry your personal accounts. When the profiles claim the same operating system as the host, so fonts and rendering fit. When every profile has its own proxy, and the antidetect tool is configured to fail closed. And when the accounts aren’t so valuable that the remaining shared-host risk is worth paying to remove.
In that setup, the host-level leaks are manageable with habits. No clipboard manager. Per-account folders. Metadata stripped before uploads. No platform desktop apps. A firewall that only lets the machine reach the proxy providers.
The machine also needs to be able to handle the load. Each open profile is a full browser. A laptop running a dozen profiles with heavy pages loaded will slow down, and slow machines produce timeouts, crashes and half-saved sessions. If your work regularly needs many profiles open at once, that’s a capacity question before it’s a separation question.
The honest test is to write down what the second machine would separate. If you can’t name a concrete thing, like personal from fleet or client A from client B, it’s probably not worth buying yet.
When separate hardware earns its cost
Separate machines earn their cost when they separate things that genuinely shouldn’t share a host.
Personal and fleet is the first and strongest case, covered above. If you currently do both on one computer, a second machine for fleet work is probably the best money you’ll spend on the whole stack.
Clients are the second. If you manage accounts for several businesses, a mistake that links one client’s accounts to another’s is a serious professional problem, regardless of what any platform does about it. Separate machines per client, or per group of clients, contain that risk. They also make it easier to hand work over, audit what was done and end an engagement cleanly.
Risk tiers are the third. High-value accounts that you can’t afford to lose shouldn’t share a host with experiments. Testing a new tool, trying an automation script, opening files from unknown sources: all of that belongs on a machine that holds nothing important.
People are the fourth. When several team members work on the fleet, each on their own machine, their habits and mistakes stay contained. A shared workstation that three people use makes it hard to know who did what.
Operating systems are the fifth. Personas that claim macOS or Linux are more convincing on a real machine running that system, for the font and rendering reasons above.
Each of these is a reason to add a machine. Profile count alone usually isn’t.
Middle options: user accounts and virtual machines
Between one machine and several, there are options that give some separation without new hardware.
Separate operating system user accounts are the simplest. Each user has its own desktop, its own files, its own browser installs and, importantly, its own clipboard session in the sense that you’re less likely to paste across them. They share hardware, fonts installed system-wide and the network. They’re a good way to separate personal from fleet work on a computer you can’t replace yet, and a weaker way to separate clients.
Virtual machines go further. Each VM has its own operating system and installed fonts, plus a separate clipboard (unless you enable sharing with the host) and separate network settings. That makes them a real improvement for file and clipboard isolation.
They carry a catch for fingerprinting. VMs usually present virtual graphics hardware, with renderer strings that name the virtualisation software or a software renderer. Pages can read those unless the antidetect profile replaces them, and replacing them while the actual rendering comes from a virtual adapter can produce the kind of mismatch detection looks for. VMs also tend to have unusual screen sizes, missing audio devices and other environment quirks.
So VMs are good for isolating your workflow and less good as a way to give profiles new hardware identities. If you use them, run the same fingerprint checks inside the VM that you’d run on real hardware, and compare.
Separate browser installs, portable apps and sandboxes offer weaker separation still. They’re useful for keeping tools apart, not for separating identities.
What several machines cost to run
Every extra machine is a small ongoing job, and it’s worth pricing that honestly before buying.
Each one needs operating system updates, antidetect browser updates and security patches, applied on a schedule. Machines that drift apart, one updated and one not, produce profiles that behave differently depending on where they live. That’s manageable with a routine, but the routine has to exist.
Each one needs backups. Profiles that live locally, or that sync but also keep local state, can be lost with a failed disk. The more machines, the more places data can quietly go missing.
Each one needs a place, power and a network connection, plus remote access if you don’t sit in front of all of them. Remote access tools are themselves something to secure.
Licensing matters too. Some antidetect plans limit how many devices can sign in to one account, or charge per seat. Check your plan before building a layout around several machines.
The hardware itself is usually the smallest cost. A used small form factor PC or an older laptop is enough to run a modest number of profiles, and the separation it buys doesn’t depend on it being fast.
What tends to go wrong in practice is neglect. The second machine gets set up with care, used for a month, then left unpatched and forgotten while profiles sit on it. If you add machines, add them to a maintenance checklist the same day, with a named owner for each.
Syncing profiles between machines
Many antidetect browsers sync profiles to the cloud so they can be opened on any machine. It’s convenient for teams and for backups. It also creates a quiet problem when the same profile opens on different hardware.
A profile’s reported values stay the same wherever it opens, because they’re stored with the profile. But the things the profile can’t fully control change with the host. The real GPU does the rendering. The real fonts do the text. The real CPU sets the timing. Open a profile on your desktop on Monday and your laptop on Tuesday, and the underlying rendering and performance characteristics shift under the same reported identity. To a detection system that watches consistency over time, that can look like a device whose hardware changes, which real devices don’t do.
How much platforms notice this is uncertain. It’s the kind of thing masking and noise are designed to cover. But the safe practice is clear: each profile has a home machine, and it opens there. Moving a profile to a different machine should be a deliberate, recorded event, like any other migration, not something that happens because a teammate clicked it from their laptop.
Record the home machine in each profile’s notes or in your fleet records. If your tool supports it, restrict which team members or devices can open each profile. And when you do move a profile permanently, expect the account to go through the same kind of adjustment it would with any device change.
A practical layout for a small operation
Here’s what I’d consider a sensible starting layout for a small fleet, scaling up only when there’s a concrete reason.
Your personal computer stays personal. No fleet profiles, no fleet spreadsheets, no fleet chat logins.
One dedicated fleet machine holds the antidetect browser and the profiles. It runs the same operating system most of your personas claim. It has no personal accounts, no clipboard manager, no platform desktop apps and a plain set of fonts. It sits on a network segment whose firewall only allows traffic to your proxy providers and the antidetect vendor.
If you manage clients, add a machine per client or per group of clients once the second client arrives, not after the first mix-up.
If you run experiments, keep a separate cheap machine for them, and wipe it periodically.
If you need personas on a different operating system, add a real machine running that system instead of stretching one host.
For phone-based accounts, the separation question moves to the devices themselves, which is where cloud phones and real handsets come in. A desktop layout doesn’t change that.
Keep a simple record of which machine holds which profiles, which accounts they serve and who uses them. It’s the map you’ll need when something goes wrong, and it’s how you notice that a profile has been opened somewhere it shouldn’t have been.
The honest limit
Separating machines reduces specific risks: host-level signals shared across profiles, cross-contamination through the clipboard and files, network fallbacks through one connection, and above all the operator’s own accounts sitting one click away. It doesn’t make accounts safe on its own. Behaviour, content and relationships between accounts still link them, whatever hardware they run on.
It’s also unclear how deeply any given platform looks at host-level rendering. Masking and noise handle the checks most platforms are known to run. Whether some platforms dig further, and how often, isn’t public, and anyone claiming precise answers is guessing.
What’s certain is that the human leaks are real, common and easy to prevent with hardware. A second machine that stops you ever logging into a fleet account from your personal browser is worth more than any fingerprint setting.
I run Singapore mobile proxy and cloud phone farms myself, and our own separation starts with the boring part: the machines that touch the fleet don’t touch anything personal. For the rest of the isolation picture, from profiles to proxies to phones, head to the Multi Account Ops home page.
Get new guides and videos first — join the Telegram channel.