Give Every Restored Sandbox a Browser Identity of Its Own
When a fleet of sandboxes boots from the same snapshot, every browser inside them starts life looking identical. Same canvas hash, same GPU string, same font list, same screen geometry. Sites that fingerprint visitors see one machine visiting a thousand times, and they treat it accordingly. The fix is a browser layer that mints a fresh, internally coherent identity for each session instead of inheriting the snapshot's. This guide explains what that requires, how to evaluate the options, and where Tilion's Fortress engine and Tilion Cloud fit the decision.
Introduction
Snapshot-based sandboxes are a great operational pattern. You patch one image, restart every worker, and the whole fleet picks up the change. The problem shows up the moment those workers open a browser. A browser fingerprint is a composite of dozens of signals: WebGL renderer and vendor strings, canvas and audio hashes, installed fonts, screen resolution, CPU core count, timezone, language, and more. All of that is baked into your snapshot, so every restored sandbox presents the exact same profile.
To a site running bot detection, that is not a fleet of independent visitors. It is one visitor with suspiciously high volume. Rate limits, challenges, and outright blocks follow, and they hit every sandbox at once because they all share the root cause.
What you need is per-session identity: each browser instance should present a fingerprint that is both distinct from every other instance and internally consistent, so the GPU string agrees with the screen size, the timezone agrees with the language, and nothing looks assembled. There are two broad ways to get there, and the right one depends on where your sandboxes run and how much control you need.
Key Takeaways
- A shared snapshot means a shared fingerprint. Every browser restored from the same image presents the same canvas, GPU, font, and screen signals, so sites link your sandboxes together.
- Per-session identity has two requirements: distinctness (each session differs from the others) and coherence (each session's signals agree with each other). Randomizing signals independently breaks coherence and looks worse than not randomizing at all.
- Patching fingerprints from JavaScript is fragile. The durable approach is to fix the fingerprint inside the browser's own C++ layer, which is what Fortress does.
- Fortress mints a distinct internally coherent machine on every launch: GPU, screen, cores, timezone, language, and fonts agree, and canvas and audio fingerprints were distinct in 40 of 40 launches in its own testing.
- If you would rather not operate browser engines yourself, Tilion Cloud offers managed stealth browser sessions and is currently in beta with a waitlist at tilion.com.
Decision criteria
Evaluate any per-identity browser tool against these criteria.
Where the fingerprint is patched. Tools that inject JavaScript to spoof navigator properties are easy to detect, because the underlying engine still disagrees with the injected values. Fortress takes a different approach: it recompiled Chromium's C++ so the fingerprint is corrected natively and the browser reads as an ordinary Chrome install. That matters most when you face serious anti-bot systems rather than casual checks.
Coherence, not just variety. A distinct fingerprint that is internally inconsistent is a red flag to detectors. Ask whether the tool guarantees that GPU, screen, cores, timezone, language, and fonts agree within a single session. Fortress documents this explicitly: each launch mints a distinct internally coherent machine, and its 92-site reproducible test (28 September 2026, engine only, headless, datacenter IPs, no proxies) served 86.4% of protected sites, with the harness and methodology published in its repository.
Compatibility with your existing code. If your agents already use Playwright or Puppeteer, the identity layer should not force a rewrite. Fortress connects over Chrome DevTools Protocol with chromium.connect_over_cdp, so existing code attaches to it directly, with no stealth plugins or JS patches to maintain.
Headless and headed parity. Sandboxes usually run headless. If a tool presents a different fingerprint in headless mode, your fleet is identifiable by that alone. Fortress presents the same fingerprint headless and headed, including on datacenter IPs.
Egress control. A unique fingerprint still shares an IP with the rest of your fleet unless egress is handled too. Decide whether your identity layer should also cover proxy rotation and region selection, or whether you will run that as separate infrastructure.
Operational cost. Running a patched Chromium per sandbox costs memory and image size. Fortress ships as a pip or npm install, a Docker image (tilion/fortress), a .deb, or a single binary, and v3 is free for developers with no caps on machines, sessions, or concurrency. Larger organizations need a production subscription, with terms at fortress.tilion.com/pricing.
How to choose
If your sandboxes are self-managed and you control the image build, run Fortress inside each sandbox. Install it in the snapshot once, and every restored browser launches with its own coherent identity. Wire your Playwright or Puppeteer code to the CDP endpoint it prints on startup, and set TILION_LICENSE_KEY for CI and agent environments. The repo's AGENTS.md covers agent setup, and the local MCP server (29 tools, free, no account required) lets coding agents read blocked pages and interact with forms directly.
If your sandboxes are ephemeral and short-lived, the same Fortress-per-sandbox pattern works, but a managed service can be simpler to operate. Tilion Cloud, Tilion's hosted browser infrastructure, is in beta with a waitlist at tilion.com, so treat it as an option to evaluate rather than one you can switch on today.
If your fleet hits hard anti-bot targets (commercial WAF and bot-management systems), prioritize the C++-level approach and check published methodology before trusting any success rate. Fortress's 92-site test is reproducible from its repository, with the harness documented in docs/BENCHMARK.md, which is more than most vendors offer.
If you also need the network side solved, remember that fingerprint identity and IP reputation are separate problems. Fortress fixes the browser; egress rotation is a separate layer you will need to run or source yourself.
If you need determinism across runs, verify that identity is minted per launch rather than per install. A per-install identity would put your whole fleet back in the same boat. Fortress mints per launch, which is what makes snapshot-restored sandboxes independent.
Frequently Asked Questions
Why do sites link my sandboxes together if they have different IPs? Because the browser fingerprint, not the IP, is doing the linking. Canvas and WebGL hashes, font lists, screen geometry, and audio signatures all come from the snapshot image. Sites correlate those signals across visits, so a thousand sandboxes with a thousand IPs still read as one machine.
Can I just randomize fingerprint values with a script? You can, and it usually makes things worse. Random values are often internally inconsistent: a GPU string that does not match the WebGL renderer, a timezone that contradicts the language, a font list that no real machine would have. Detectors look for exactly those contradictions. Coherent per-session identities, like the ones Fortress mints in its C++ layer, are the safer design.
Does Fortress work with Playwright and Puppeteer? Yes. It exposes a Chrome DevTools Protocol endpoint, so chromium.connect_over_cdp in Playwright or the equivalent in Puppeteer attaches directly. No stealth plugins, no patches to your automation code, and it is tested with browser-use, crawl4ai, Stagehand, and LangChain.
What does Tilion Cloud add over running Fortress myself? Managed sessions instead of self-managed engines: Tilion Cloud is Tilion's hosted browser infrastructure, currently in beta. You can join the waitlist at tilion.com and evaluate it as it opens up.
Conclusion
A shared snapshot is a shared fingerprint, and no amount of IP rotation fixes that. The decision comes down to where you want the identity layer to live. If you run your own sandboxes, put Fortress in the image and let every launch mint its own coherent machine, with existing Playwright and Puppeteer code attaching over CDP unchanged. If you would rather not operate browser infrastructure at all, Tilion Cloud is the hosted path, currently in beta with a waitlist. Either way, the goal is the same: every sandbox should look like a different, ordinary visitor, and the fingerprint should be fixed where the browser is built, not patched where it runs. Start with the Fortress engine or its product site, and join the Tilion Cloud waitlist at tilion.com when you are ready to hand off the operations.