← back to blog

Rebuilding A Profile After The Antidetect Vendor Changes Its Engine

The release note is usually short. New browser core, several major versions ahead of the old one, improved fingerprint handling, old core deprecated at the end of the quarter. Then a button in every profile’s settings that says “update to latest core”, and a banner on older profiles saying they’re out of date.

What the note doesn’t say is what happens to each profile when you press that button. Some values change because the engine changed and there’s nothing you can do about it. Some change because the tool regenerates them unless you stop it. Some should stay exactly as they are, because they’re the part of the profile the platform has been recognising for months. Pressing the button on forty profiles in one afternoon treats all three categories the same.

This is a hands-on piece about that moment: a vendor engine change, a fleet of existing profiles, and the job of moving them across without making each account look like it got a new computer. The broader question of keeping browser versions current over time has its own article. This one is narrower. One big change, done carefully.

What an engine change actually is

Antidetect browsers are built on real browser engines, mostly Chromium, some on Firefox. The vendor takes an engine release, applies its own patches for fingerprint control and profile management, and ships it as the “core” that profiles run on. Most of the time, cores are updated in small steps that track the upstream browser. An engine change is the bigger event.

Sometimes it’s a jump across several major versions, because the vendor fell behind and is catching up. Sometimes it’s a rewrite of how the tool applies fingerprint changes, for example moving from JavaScript-level overrides to patches inside the engine. Sometimes it’s a switch of base entirely. And sometimes the vendor changes how it generates values like canvas noise, so the same profile settings produce different outputs on the new core.

Each of these changes what a profile looks like from the outside, in different ways. A version jump changes the browser’s reported version and its feature set. A spoofing rewrite can change how consistent the profile’s values are with each other, usually for the better. A noise algorithm change can alter the canvas, WebGL and audio outputs that some checks use as stable identifiers.

The first job is finding out which kind of change you’re dealing with. Read the release notes carefully and look for anything about fingerprint generation, noise or “improved consistency”. Check the vendor’s documentation or support channel for whether existing profiles keep their values or get regenerated. If the vendor doesn’t say, assume some values will change and plan to measure them.

Why old profiles start to look stale

It’s tempting to leave profiles on the old core as long as the vendor allows. Nothing is broken, the accounts are working, and every migration carries risk. That’s a reasonable instinct for a few weeks. It gets worse with time.

A profile on an old core claims to be a browser version that fewer and fewer real users run. Chromium-based browsers update automatically for most people, so the real population moves forward within weeks of each release. A profile stuck several versions behind becomes part of a shrinking minority, and minorities are more distinctive.

The old core also stops getting fixes. Security patches in the upstream engine don’t reach it. Websites start using features it doesn’t support, so pages break or behave oddly. And the vendor’s fingerprint work moves on. If detection vendors find a new way to spot the old core’s patches, that won’t be fixed on the old core.

Eventually the vendor retires the old core, often with a deadline. After that date, profiles may be migrated automatically on launch, or may refuse to open until you migrate them. A forced migration on the vendor’s schedule, all profiles at once when someone opens them, is exactly the kind of fleet-wide event you want to avoid.

So the practical choice is between migrating deliberately, on your schedule and in waves, or being migrated on the vendor’s schedule all at once. The deliberate option is more work up front and much less risky.

Snapshot every profile before touching it

Before anything changes, record what each profile currently looks like. Without a before picture, you can’t tell afterwards which changes you intended and which ones crept in.

There are two parts to the snapshot. The first is the configuration: the profile’s settings in the antidetect tool. Operating system and version, browser version, screen resolution, hardware concurrency, device memory, graphics renderer, time zone, language, fonts setting, WebRTC mode, proxy details, extensions. Many tools can export this as a file. If yours can’t, a screenshot of every settings page is better than nothing.

The second is the observed fingerprint: what a page actually sees when the profile loads. Open the profile, visit one or two fingerprint check pages, and save the full reports. Record the user agent string and client hints, the screen and window values, the canvas, WebGL and audio hashes, the font list and anything else the pages show. Save the reports with the profile ID and the date.

Then back up the profile’s data. Cookies, local storage, saved sessions, whatever the tool keeps. An engine change can alter how data is stored, and a failed migration without a backup means logging every account in again from scratch.

This takes a few minutes per profile, and for a large fleet it’s tedious. Script what you can. But don’t skip it for the valuable accounts. When a platform starts asking one of them for verification after the migration, the snapshot is how you’ll find out what changed.

Reading the before and after comparison

The snapshot only helps if you compare it properly. After each migration, put the old and new fingerprint reports side by side and sort every difference into one of three piles.

The first pile is expected. The browser version in the user agent and client hints went up. Some feature detection results changed. A handful of WebGL parameters shifted. These are the engine-bound values, and they should have moved. Check only that they moved together, so the user agent and the client hints report the same new version.

The second pile is unexpected. The screen resolution changed. The hardware concurrency changed. The time zone, language or font list changed. The graphics renderer names a different card. These are continuity values, and a change here usually means the migration regenerated something it shouldn’t have. Fix them in the profile settings and test again before the account is used.

The third pile is unknown: differences you can’t explain. A new value appearing in a report that wasn’t there before, or a hash changing when the vendor said noise was preserved. Don’t guess. Ask the vendor, check the release notes again, compare with a second profile that migrated the same way. If several profiles show the same unknown change, it’s probably the engine. If only one does, it’s probably that profile.

Text reports are easier to compare than screenshots. If your fingerprint check page can export JSON or copyable text, use it, and a simple diff tool will show every changed line. For a large fleet, a small script that pulls the same fields from each report and flags differences saves hours.

Keep the comparison with the profile’s migration record. It’s the evidence that the migration did what you intended.

Fields that should follow the engine

Some profile values are tied to the engine, and they should change when the engine changes. Keeping them at the old values would make the profile inconsistent.

The browser version is the obvious one. The user agent string and the client hints both report the browser version, and they need to match what the engine actually is. A profile claiming the old version while running the new engine behaves like one browser and describes itself as another, and feature detection will expose it. Most tools update this automatically with the core. Check that they did, in both the user agent and the client hints.

Feature support follows the engine too. New engine versions add JavaScript APIs, CSS features and media capabilities, and occasionally remove old ones. You don’t set these. They come with the engine. They’re one reason the version string has to move, since a page can compare what the browser claims with what it can actually do.

Some WebGL details are partly engine-dependent, such as certain supported extensions and parameters, even though the renderer name comes from the graphics hardware. Let the tool handle these, and compare them in your before and after reports.

Extensions may need updating for compatibility with the new engine. Chromium’s move away from the older extension format, Manifest V2, means some old extensions simply stop working on newer cores. If an extension your profiles depend on breaks, replace it with a maintained alternative rather than keeping profiles on an old core for its sake.

The rule for this group is to let it move, and to check that it moved consistently.

Fields to keep for continuity

The other group is everything that describes the device and the person rather than the browser engine. These should stay exactly as they were, because they’re what makes the profile recognisably the same device to the platform.

The operating system and its version stay, unless the old version has become implausibly outdated, which is a separate decision covered below. The screen values stay, resolution and pixel ratio included. Hardware concurrency and device memory stay. The graphics renderer and vendor stay, since a browser update doesn’t change the graphics card. Time zone and language stay. The font setting stays, because real people’s fonts don’t change when their browser updates. The WebRTC setting stays. The proxy and exit stay, and this is not the week to change them.

Stored data stays. Cookies, local storage and logged-in sessions are the strongest continuity signal there is. A profile that migrates with its sessions intact looks like the same browser after an update. A profile that loses them and logs in fresh looks like a new browser on an old account, which is a much louder event.

The risk here is tools that regenerate values during migration. Some migration flows offer to “refresh the fingerprint” or apply “recommended settings for the new core”, and accepting that can reroll the screen size, hardware values or renderer as well as the version. Read every dialog. If the tool gives you a choice between keeping current settings and generating new ones, keep them.

After migration, compare the new configuration with the snapshot, field by field. Anything in this group that changed needs to be put back, if the tool allows it.

Noise and hashes that change anyway

There’s a third group that sits awkwardly between the two: values you’d like to keep but may not be able to, because the vendor changed how they’re produced.

Canvas, WebGL and audio fingerprints in antidetect profiles are usually shaped by noise. The tool adds small, consistent variations to what the page reads back, driven by a per-profile seed, so each profile produces its own stable hash. If the new core keeps the same seed and the same noise method, the hashes may stay the same, or change only slightly because the underlying rendering changed with the engine. If the vendor changed the noise method, every profile’s hashes change, even though the settings look identical.

You can’t stop this from your side. What you can do is know about it. Compare the hashes in your before and after reports. If they changed, the profiles now look like devices whose rendering output changed overnight. That happens to real devices after driver and browser updates, so it’s survivable. But it happening to your whole fleet on the same day is a pattern, which is another reason to migrate in waves.

It also sharpens the question of whether to migrate valuable accounts early or late. Early means less time on an ageing core. Late means you’ve seen how the new core’s changes affect accounts you care less about. For most fleets, late is safer for the accounts that matter most, as long as it’s well before the vendor’s deadline.

If the vendor has a setting to preserve legacy noise behaviour for existing profiles, it’s worth considering for continuity, but check that it doesn’t create a mismatch between the old noise pattern and the new engine.

Pick a pilot group

Don’t start with the fleet. Start with a small pilot group of profiles whose accounts you can afford to lose, or at least afford to have questioned.

Choose profiles that represent the variety in your fleet. Different operating system claims, different platforms, different proxy types. A pilot that only covers one kind of profile won’t tell you how the others will behave.

Migrate the pilot group following your full process: snapshot, back up, migrate, compare, fix any drift, test. Then use those accounts normally, at their usual pace, for a week or so. Don’t hammer them to see what happens. The point is to see whether normal use on the new core draws any reaction.

Watch for friction. Extra verification prompts, captchas where there weren’t any, sessions expiring sooner than usual, features asking for confirmation. Compare the pilot group’s week with its previous weeks, and with a similar set of profiles still on the old core. A little friction right after migration is normal, because the platform sees an updated browser. Friction that persists or grows is a sign that something in the migration made the profile look inconsistent.

Also watch for practical problems. Pages that render differently, extensions that don’t work, automation scripts that fail, sessions that didn’t survive.

If the pilot goes badly, stop and investigate before moving anything else. Compare the pilot’s before and after reports field by field. Talk to the vendor’s support. It’s much better to find a migration problem on five low-value profiles than on fifty.

Keeping teammates off the update button

In a team, the biggest risk to a careful migration plan is someone else clicking the update banner.

Antidetect tools tend to make updating easy on purpose. A banner on every old profile, a one-click update, sometimes a prompt at launch. A teammate who opens a profile to do their normal work, sees “your profile is out of date” and clicks update has just migrated that profile outside your plan, without a snapshot, without a backup and possibly with regenerated values.

So the migration plan has to be shared, not just written. Tell everyone which profiles are in which wave, when each wave runs and who does it. Ask them not to accept update prompts on profiles outside the current wave. If the tool supports it, restrict who can change profile settings or update cores, so only the person running the migration can do it.

Some tools let you pin a profile to its current core until you choose to move it. Use that if it exists, since it removes the temptation entirely.

Check after each wave that nothing outside it moved. Compare core versions across the fleet with your plan. A profile that migrated early by accident isn’t a disaster, but it needs its before and after comparison done from whatever snapshot you have, and it should be noted in the record.

Automation deserves the same attention. A script that opens profiles through the local API may trigger an automatic migration on launch, if the tool does that for old cores. Know how your tool behaves, and pause scripted runs on profiles that haven’t been migrated deliberately yet.

Roll out in waves

Once the pilot is clean, migrate the rest in waves rather than all at once.

The reason is the same one that applies to any fleet-wide change. Real users don’t all update their browsers in the same hour. A fleet in which every profile moves to a new browser version, and possibly new rendering hashes, on the same afternoon produces a synchronised change that no group of unrelated people shows. Spreading the migration over a couple of weeks breaks that up.

Order the waves by value, lowest first. Each wave gets the full process: snapshot, back up, migrate, compare, test. Leave a few days between waves so you can see whether anything unusual follows each one.

Mix the waves across platforms and proxy groups rather than migrating all of one platform’s accounts together. If something about the new core doesn’t agree with a specific platform, you want to find out from a few accounts, not all of them.

Keep the vendor’s deadline in view. Plan the waves so the last one finishes comfortably before the old core is retired, with a margin for the waves that need to pause while you investigate something.

And keep the pace of account activity normal during the rollout. The session right after migration is one where the platform sees an updated browser. Let it be an ordinary, quiet session. Log in, look around, leave. Save anything important for later in the week.

When sessions don’t survive

Sometimes the migration loses stored data. The new core uses a different storage format, the conversion fails, or the tool simply starts the migrated profile with an empty cookie jar. Now every account on that profile needs a fresh login.

A fresh login on an existing account from a browser with no history is one of the louder things you can do. The platform sees a device it doesn’t recognise, or recognises only partly, and it may ask for a password, a code or a verification step. That’s manageable for one account. For a whole wave, it’s a lot of identical events at once.

The first defence is the backup. If the tool supports importing cookies and storage, restore the backed-up data into the migrated profile before opening any platform. Check that the sessions are live by opening a harmless page on each site.

If sessions can’t be restored, space out the fresh logins. Don’t log into forty accounts in an hour. Treat each one like a login from a new device: the right proxy, the right time of day for the persona, the recovery details ready, and a quiet session afterwards.

And look at why it happened before continuing the rollout. If the pilot kept its sessions and a later wave lost them, something differs between those profiles, and the next wave may have the same problem.

Record which accounts had to log in fresh, and when. If verification prompts cluster in the following days, you’ll want to know whether they line up with the forced logins or with something else.

Automation and extensions after the change

Profiles don’t live alone. Scripts and extensions that worked on the old core can break on the new one, and it’s better to find out on the pilot group than on the fleet.

Automation frameworks connect to the browser over its debugging protocol, and each framework version expects a particular range of browser versions. A jump of several major versions in the core can leave your framework version out of step. Most commands keep working, and a few fail in ways that are hard to diagnose. Pin the framework version, test your scripts against a pilot profile on the new core, and upgrade the framework deliberately if needed.

Extensions face their own compatibility changes. Some rely on APIs that newer engines have removed or restricted. Some are simply unmaintained. If an extension stops working, don’t hold profiles on the old core to keep it. Find a maintained replacement, or drop it if it wasn’t essential.

Remember that extensions are visible to pages in some cases, and an extension change is a small change in how the profile looks. Update them as part of the migration, at the same time as the core, rather than as a separate event a week later.

Also check any tool that reads the profile’s data directly, like cookie exporters or backup scripts. A change in storage format can break them silently, and you may not notice until you need a backup that turns out to be empty.

When to rebuild from scratch

Sometimes migration isn’t possible. The profile won’t convert, the data is corrupted, or the old configuration has problems the new core won’t accept. Then the choice is between rebuilding the profile and retiring it.

Rebuilding means creating a new profile on the new core, configured to match the old one’s device description as closely as possible, and moving the account’s data across if you have it. From the platform’s side, if the data comes across, it looks like the same browser after a large update. If it doesn’t, it looks like a new device. Plan for the second case.

When you rebuild, use your snapshot. Set the operating system, screen, hardware values, renderer, time zone, language and fonts to match the old profile. Use the same proxy and exit. Import the backed-up cookies and storage. Then compare the new profile’s fingerprint report with the old one and fix any differences in the fields that should have stayed the same.

Treat the first login on a rebuilt profile like a device move. Expect a check, answer it calmly, and keep the account’s activity quiet for a while.

Retiring is the right answer for profiles whose accounts aren’t worth the risk of a visible device change, or whose configuration was never good to begin with. A profile that was already inconsistent before the migration doesn’t become consistent by being rebuilt faithfully. Sometimes the kinder option is to rebuild properly, as a new device, and accept the adjustment period.

Don’t roll back, and when to modernise the OS claim

Two decisions come up during most migrations and deserve a clear answer.

The first is rollback. If a profile behaves badly on the new core, the temptation is to move it back to the old one. Don’t. Browsers only update forward in real life. A profile that reports a newer version one week and an older one the next is doing something no real browser does. If a migrated profile is having problems, pause it while you investigate, fix the drift in its configuration, or rebuild it. Going backwards adds a strange event on top of the original one.

The second is the operating system. An engine change is sometimes a prompt to notice that a profile’s claimed operating system is getting old. A profile claiming an operating system version that has dropped out of common use, running a brand new browser core, is a slightly odd combination. Real people on old systems often end up on old browsers too, because newer browsers drop support for old systems.

The honest answer is to change one thing at a time. Migrate the core first, with the operating system claim unchanged. Let the profile settle for a few weeks. Then, if the operating system claim needs updating, do it as a separate, deliberate change, like a real user upgrading their system. Doing both at once makes the profile look like a different computer, and makes it impossible to tell which change caused any trouble that follows.

Record the migration

Keep a record per profile of what happened. The date it moved, the old and new core versions, whether sessions survived, any fields that drifted and were fixed, and anything unusual in the following week.

It sounds like paperwork. It’s the only way to answer the question that will come up a month later, when some accounts start behaving oddly: is this about the migration, or about something else? With the record, you can check whether the affected accounts share a wave, a core version or a fresh login. Without it, you’re guessing.

The record also helps with the next migration. Vendors change engines more than once, and the notes from this one, which fields drifted, which extensions broke, which scripts needed changes, turn the next one into a checklist.

Keep the snapshots too, at least until the next migration. They’re the reference for what each profile looked like before, and they’re what you’ll use if a profile ever needs rebuilding.

The honest limit

A careful migration removes the avoidable risks of an engine change: accidental regeneration, drift in fields that should stay fixed, lost sessions, broken scripts and a synchronised fleet-wide event. It can’t remove the changes the vendor made on purpose, like a new noise method or a new rendering baseline. Those will make profiles look somewhat different whatever you do, and how much any platform cares about that isn’t something anyone outside the platform can measure.

It also can’t fix profiles that were inconsistent before. If a profile already described a device that couldn’t exist, a faithful migration carries that problem to the new core.

What’s reliable is that deliberate, staggered migrations with a before and after comparison are much quieter than a forced migration on the vendor’s deadline. The work is mostly clerical, and it’s the kind of clerical work that saves accounts.

I run Singapore mobile proxy and cloud phone farms myself, and profile migrations here follow this same pattern: snapshot, pilot, waves, record. For the rest of the profile maintenance picture, from backups to keeping versions current, head to the Multi Account Ops home page.

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

need infra for this today?