← back to blog

Staying On An Old Chromium Build And What It Costs You

The number nobody thinks to check

When people audit a browser profile before running it, they check the proxy, they check the canvas noise settings, they check the timezone and the language headers. Almost nobody opens a fresh tab and asks: what Chromium build is this thing actually claiming to be, and does that number make sense next to everything else in the fingerprint?

I run proxy farms and cloud phone fleets for a living. I test anti-detect browsers hands-on against real detection scripts as part of that work. The Chromium version string is one of the least glamorous parts of a fingerprint. It’s also one of the most consistently overlooked. It feels like metadata, not a real signal, so nobody talks about it the way they talk about canvas spoofing or WebRTC leaks. But it’s a timestamp, stamped into dozens of engine behaviors at once, and a detection system that knows how to read it gets a high-confidence tell almost for free.

This piece covers what that version number actually encodes, where it leaks from beyond the obvious User-Agent string, why anti-detect vendors structurally can’t keep every profile on Chrome’s bleeding edge, and what a stale build costs you in practice. Version freshness is one input into a much bigger risk picture. I want to walk through it honestly, not sell it as a silver bullet.

What a “Chromium build” actually is

Chrome, Edge, Brave, Opera, and the browser engine underneath nearly every anti-detect tool on the market (Multilogin, GoLogin, Kameleo, AdsPower, Dolphin Anty, and the rest) are all forks or wrappers around the open source Chromium project. Chromium is a rolling codebase that ships a new major version roughly every four weeks. The V8 JavaScript engine, the Blink rendering engine, the networking stack, and hundreds of Web APIs all move together as a single dated snapshot. None of it settles into a fixed, unchanging state.

The version string itself (something like 128.0.6613.84) isn’t decorative. The first number is the major release, tied to a specific four-week cycle. The numbers after it track minor patches and security fixes within that cycle. Every one of those numbers corresponds to a real, documented set of engine behaviors: which CSS features are supported, how the JS engine optimizes certain array operations, what the Permissions API returns for a given prompt type. It also determines whether WebGPU is enabled by default and how the audio context handles a particular sample rate.

When a browser reports itself as Chromium 128, it is implicitly making a claim about all of that surrounding behavior, not just the string in the address bar. A real Chromium 128 install didn’t get that number assigned arbitrarily. It got built from a specific commit in the Chromium source tree on a specific date, with every one of those subsystems compiled from that same snapshot. That’s the part that matters for fingerprinting. It’s easy to forget when you’re focused on the parts of a profile you can see and adjust directly, like the proxy or the canvas noise slider.

Where the version number actually shows up

The most visible leak point is navigator.userAgent, the string every site can read in one line of JavaScript. But modern Chromium has mostly moved away from relying on that string alone. User-Agent Client Hints (navigator.userAgentData and the Sec-CH-UA family of request headers) were introduced to give servers a structured, queryable way to ask for browser and platform details without parsing a string. They don’t expose every detail to every site by default.

That matters because Client Hints expose version data in more than one place at once. A site can read the low-entropy Sec-CH-UA header on every request without asking permission and get the browser brand and a rough version for free. Want more? Call getHighEntropyValues() and request the full version, the platform version, the architecture, and whether the browser is running on a mobile device. All of that comes back from the browser engine itself, not from a single editable string. The response even includes a full version list, covering the browser’s own brand alongside the “not:A-Brand” and Chromium entries that Chrome deliberately injects so sites can’t hard-code assumptions about which brands exist.

This is the first place a spoofing mismatch shows up. If a tool patches navigator.userAgent to claim Chrome 128 but leaves the underlying Client Hints response reporting a different build, or, worse, leaves gaps where a real Chrome 128 install would return a consistent, fully populated response, that gap is trivially detectable with a few lines of comparison code. Any competent fingerprinting script checks the UA string against the Client Hints response before it even gets to the more exotic checks. It’s the cheapest possible test to run, and it catches the laziest spoofing attempts outright.

The places you can’t just spoof away

Overwriting the User-Agent string and patching the Client Hints response covers the two most obvious leak points. But the version number is baked into the engine at a much deeper level than any string you can rewrite from the outside.

Every Chromium release adds, removes, or changes the behavior of specific JavaScript APIs. Newer builds support certain Intl methods and certain CSS container query behaviors that older builds simply don’t have, no matter what string they claim. A detection script that wants to verify a claimed version doesn’t need to trust the UA string at all. It can feature-test the engine directly: try calling a method that only exists in Chromium 126 and later, or check whether a particular CSS property parses. Each test takes a handful of lines and runs in milliseconds. A script can chain a dozen of them together to build a confidence score for what build is actually running underneath the claimed one. If the browser claims Chromium 128 but the engine behaves like Chromium 118, that’s a mismatch no header patch can hide. The test probes real engine behavior, not a claim about it.

This is the practical limit of spoofing as a strategy. A tool can change what a browser says about itself far more easily than it can change what the browser actually does, because the “does” part is compiled into the engine binary. Anti-detect vendors that build their spoofing layer on top of an old Chromium base are stuck patching strings around an engine whose real behavior hasn’t moved. That gap is exactly where a good detection script goes looking, and no amount of careful string-level patching closes it. That gap always shows.

Why anti-detect vendors run behind Chrome’s own release train

It’s worth being fair to the vendors here, this isn’t a case of anyone being lazy. Chrome ships a new stable major version roughly every four weeks. Each release can shift dozens of the exact APIs that anti-detect browsers need to patch for fingerprint spoofing: canvas rendering, WebGL parameter reporting, font enumeration. Every time Chromium moves, the fingerprint-relevant surface moves with it, and a vendor has to re-verify or re-patch their spoofing layer against the new base before shipping it to customers.

That work isn’t just recompiling against a newer source tree. A vendor has to re-test every existing spoofing patch against the new build, re-verify that canvas and WebGL noise still produces output statistically consistent with a real install of that version, and often re-run their own internal detection checks for a fresh mismatch elsewhere in the fingerprint. Skipping that verification to ship faster trades one stale-build risk for a harder-to-spot breakage risk, which is why vendors that take this seriously end up trailing Chrome’s release train by design, not by accident. It’s the cost of forking a fast-moving open source project and layering spoofing patches on top of it release after release. Not a flaw specific to any one tool.

The practical result: at any given moment, the anti-detect browsers on the market are distributed across a range of Chromium bases, some closer to current stable than others. That range shifts every few weeks as vendors catch up and Chrome moves again. This isn’t about naming a winner, I haven’t run a controlled side-by-side benchmark of update cadence across all five tools, and I’m not going to invent one. It’s about understanding why “check what build your profile is actually running” has to be an ongoing habit, not a one-time setup step.

What a detection system sees when your build is stale

Here’s the mechanism that makes an old build costly even when every individual spoofing patch is technically sound. Chrome auto-updates aggressively on real user devices, silently, in the background, usually within days of a new stable release going out. That means the real-world population of organic Chrome traffic clusters tightly around the newest handful of versions at any given time. A detection vendor with visibility into large volumes of traffic, and the major fraud and bot detection companies that platforms buy from do have this visibility, can build a live picture of what the “normal” version distribution looks like this week. That picture updates continuously as new releases roll out and old ones fade from the population.

A browser claiming a version that dropped out of that recent cluster weeks or months ago is sitting in a thinning tail of the distribution. That tail is disproportionately populated by exactly the traffic detection systems are built to flag: scrapers running old headless builds, enterprise images that haven’t been patched, and yes, anti-detect profiles running behind a spoofing layer that hasn’t been rebuilt against a current Chromium base. The older the claimed version, the thinner that tail gets. The thinner the tail, the more a single data point stands out against it.

Being in that tail is a probabilistic signal, one input among many that a risk score weighs, not proof about any individual session. But it’s a cheap, high-confidence input to compute, it requires nothing more exotic than comparing a version string against a known distribution. That’s exactly why it’s worth taking seriously. A signal that costs almost nothing to check and correlates reliably with unwanted traffic is the kind of thing a detection system runs on every request, not the kind it saves for suspicious ones. It runs on everyone.

TLS and network-level version tells

The version fingerprint doesn’t stop at the JavaScript layer. Chromium’s network stack, the part that negotiates the TLS handshake before any HTTP request even happens, also changes across releases. The order of cipher suites offered, the extensions included in the ClientHello, and the GREASE values Chromium inserts to prevent protocol ossification have all shifted between different Chromium versions over the years.

GREASE deserves a quick explanation, since it’s easy to mistake for randomness rather than a version tell. Chromium deliberately inserts fake, reserved values into the ClientHello (fake cipher suites, fake extensions) specifically to stop middleboxes and servers from hard-coding assumptions about what a “valid” handshake looks like. The GREASE values themselves rotate, but the pattern of where they’re inserted and how many appear is consistent within a given Chromium version and shifts when the networking stack changes. That means even the parts of the handshake designed to look random still carry a version signature. You just need to know what to look for.

TLS doesn’t lie.

That handshake gets fingerprinted independently of anything JavaScript reports, using techniques like JA3 or JA4, which hash the structure of the ClientHello into a compact signature. A site can compute that signature before your page even loads and compare it against known signatures for specific Chromium versions. If a browser presents a JA3/JA4 signature associated with Chromium 118 while its User-Agent and Client Hints claim Chromium 128, that’s a mismatch with nothing to do with JavaScript-level spoofing. No amount of patching navigator.userAgentData fixes it. The mismatch lives in a completely different layer of the network stack, one that never routes through the JavaScript engine at all.

This is a real weak point for anti-detect tools that spoof the JS-visible fingerprint carefully but run on an outdated underlying Chromium binary. The TLS layer is determined by the actual network stack compiled into the browser, not something a JS injection can touch. It moves at the same slow pace as the vendor’s base Chromium update, not the pace of whatever spoofing patches ship on top. A vendor can ship a perfectly convincing canvas and WebGL patch on Monday and still leak a two-version-old TLS signature on the exact same release.

Canvas, WebGL, and audio fingerprints drift with the build too

Rendering fingerprints aren’t static either. Canvas fingerprinting, WebGL parameter reporting, and AudioContext fingerprinting all depend on the underlying graphics and audio stack, and that stack changes between Chromium releases as Google updates the ANGLE translation layer, the Skia rendering library, and various audio processing internals.

ANGLE is worth understanding specifically, because it’s the layer that translates WebGL and Canvas 2D calls into whatever graphics API the host operating system actually uses underneath (Direct3D on Windows, Metal on macOS, Vulkan increasingly across both). Every time Google updates ANGLE, the exact sequence of floating-point operations that produce a given canvas or WebGL output can shift by fractions of a value. That’s more than enough to change the fingerprint hash even though nothing about the visible image changes at all. Skia updates do the same thing on the 2D rendering side.

Pixels drift too.

This means the exact bytes a canvas fingerprint produces, or the exact set of WebGL extensions and parameters a real Chrome 128 install reports, are themselves tied to that specific build. An anti-detect browser applying canvas noise or WebGL spoofing on top of an old rendering engine is trying to produce output that convincingly looks like current Chrome, using a renderer that never actually produced current Chrome’s real output in the first place. The noise pattern might be well designed and statistically indistinguishable from real device-to-device variance in isolation. But it’s layered onto a baseline that doesn’t match what it claims to be, a harder problem to paper over than getting the noise distribution right.

A detection script sophisticated enough to fingerprint at this level (and the major commercial fraud detection vendors are) can, in principle, compare the statistical texture of a canvas or WebGL fingerprint against known signatures for the claimed version. Not every site runs this check, it’s more expensive to compute than a simple version-string comparison, but it’s a layer of scrutiny that stacks on top of everything above it. The version number is a claim that touches strings, headers, network handshakes, and rendering output all at once. Not one signal, four. Staying consistent across every one of those layers gets harder the older the underlying build gets.

A worked example from checking a real profile

Here’s what actually checking this looks like in practice. I open a profile, load a page that reports navigator.userAgent and calls navigator.userAgentData.getHighEntropyValues(['fullVersionList', 'platformVersion', 'architecture']), and write down what comes back. Then I compare that reported version against Chromium’s own public release dashboard, which lists the current stable channel version and roughly how many weeks old it is.

Three or four release cycles behind current stable is roughly three to four months of drift, well outside the tight cluster that organic Chrome traffic sits in. From there I check whether the Client Hints response and the UA string actually agree with each other; a mismatch between the two is a red flag on its own. I also check the low-entropy Sec-CH-UA header against the high-entropy getHighEntropyValues() result, because I’ve seen profiles where the two disagree on the exact patch number even though the major version matches, a subtler tell than an outright brand mismatch, but just as readable to a script that checks both.

Separately, I run a TLS fingerprint check against the profile’s outbound connection, using one of the free online ClientHello inspectors, to see whether the JA3/JA4 signature is consistent with the claimed browser version. If that signature points to a materially older Chromium build than the JS layer claims, that gap is baked into the binary underneath the spoofing patches, no patch closes it. The only real fix is a newer base version from the vendor.

None of this is a bypass technique. It’s the same kind of hygiene check you’d run on a server before deploying it: is the software actually the version it claims to be, and do the pieces agree with each other. It tells you whether the profile is internally consistent, which is a prerequisite for looking normal, not a guarantee of it. A profile can pass every one of these checks cleanly and still get flagged on a completely different signal, worth sitting with, rather than treating this checklist as a pass/fail gate on its own.

How this compounds with everything else in a profile

A stale Chromium build on its own rarely bans an account outright. Risk scoring systems built by fraud and bot detection vendors work by combining many weak signals into one score, not by hard-failing on any single input. Version staleness is one of those weak signals, sitting alongside proxy reputation, IP geolocation consistency, account age and history, behavioral timing patterns, and dozens of other fingerprint components.

What makes version drift worth fixing is that it stacks, not that it’s a dealbreaker by itself. A profile running a proxy with clean residential reputation, a timezone and locale that match the proxy’s geography, an account with real history, and a Chromium build that’s a few weeks old looks like one thing to a risk model. Swap in a Chromium build that’s eight months stale and there’s an additional weak flag layered on top, nudging the composite score in the wrong direction. On a fresh account with thin history and a lower-reputation proxy, that extra nudge matters more. There’s less good signal elsewhere to offset it.

Think of it less like a single gate you either pass or fail, and more like a running tally where each weak signal adds or subtracts a small amount. A stale version doesn’t subtract enough on its own to flip a healthy profile into a flagged one. But on a profile that’s already sitting close to a threshold for other reasons, it can be exactly the margin that tips the score over. That’s why fixing version drift feels invisible when it works: nothing visibly changes, because the signal simply stops being there to add to the pile.

This is why I don’t treat version freshness as a fix for anything by itself, and why nothing in this piece is a claim that keeping your build current makes an account safe. It’s maintenance, the same category as rotating a burned proxy or not reusing a canvas seed across ten profiles. It removes one weak signal from the pile. It doesn’t remove the pile.

What the major anti-detect tools do about updates

Across the category, Multilogin, GoLogin, Kameleo, AdsPower, Dolphin Anty, and similar tools all build their spoofing layer on top of a Chromium base that they have to periodically rebuild and re-verify as Chrome moves forward. Some of these tools let you choose from a handful of recent Chromium versions per profile, so you can spread a fleet across a realistic range rather than clustering everything on one build. Others push a single current base to the whole install and update it centrally. That’s simpler, but it means every profile moves together whenever the vendor ships an update, the whole fleet ages in lockstep between updates, rather than gradually, the way a real user population does.

I’m not going to put specific update-speed numbers on any of these vendors here, that lag changes release to release, and I don’t have controlled benchmark data comparing them against each other. What I can say, from testing these tools hands-on, is that update cadence is a real, variable feature of the category, not a fixed property of any single product. It’s worth checking directly rather than assuming. A vendor that shipped a fast update last cycle isn’t guaranteed to ship the next one just as fast, cadence depends on engineering headcount and priorities that shift over time.

The practical way to check it yourself: look at a vendor’s changelog for the underlying Chromium version they currently ship, and compare that date against Chromium’s own public stable release dates. Not every vendor publishes this cleanly. Some bury it in a support article or an about page; a few don’t document it at all, in which case reading the version straight out of the running profile is the more reliable path. That comparison tells you far more than any general claim I could make about the category as a whole.

Myths about fixing it

A few things worth clearing up. Changing the User-Agent string alone doesn’t fix a stale build. Everything from Client Hints to the TLS handshake to rendering output moves independently of that one string, a detection script that only checks the UA string is the easy case, not the hard one. Plenty of free browser extensions promise to “change your Chrome version” and do exactly this: rewrite the one string a novice thinks to check, while leaving Client Hints, the TLS stack, and the rendering engine completely untouched underneath. That’s not enough.

Running the absolute newest Chromium build isn’t automatically safer either. A version still on the beta or dev channel, or one that shipped to stable within the last day or two, hasn’t reached meaningful adoption in the organic population yet. It can sit in a thin part of the distribution too, just on the opposite end from stale. The target is whatever the bulk of real users are currently running, usually the current stable channel a week or two after release, once auto-update has caught up across the real-world install base. Chasing the bleeding edge trades one outlier status for another, often a less predictable one, since a brand-new release’s adoption curve changes day to day, while an eight-month-old build’s rarity is stable and easy to reason about.

Picking one Chromium version and freezing every profile in a fleet on it forever is its own failure mode. Real users don’t all sit on identical versions at any given moment, auto-update rolls out gradually, and not everyone restarts their browser the same day. A fleet where every profile reports the exact same build, updated on the exact same day, is its own kind of unnatural clustering, even if that build happens to be current. A site that sees a hundred sessions all report the identical patch-level version number, created within the same window, has a pattern to notice. The goal is a spread that resembles the real population, refreshed periodically rather than set once and forgotten.

What to actually check on Monday

Concretely, here’s the maintenance list. Pull up each profile or browser you’re actually running and read back what navigator.userAgent and navigator.userAgentData.getHighEntropyValues() report. Compare the version against Chromium’s public release dashboard and note how many weeks old it is. If it’s more than a cycle or two behind current stable, that’s worth flagging.

Check whether your anti-detect tool’s release notes mention which Chromium base the current app version is built on, and how recently that base was updated relative to Chrome’s own release. If it lets you choose between multiple Chromium versions per profile, use that to spread a fleet across a small range of recent versions. Clustering every profile on the single oldest option happens by default if nobody touches the setting.

Separately, run a TLS ClientHello check against a live connection from the profile and compare the resulting JA3 or JA4 signature against what’s expected for the claimed version. This catches network-layer mismatches that JS-level checks can’t see. Run it on a sample of profiles rather than just one, a vendor update can land cleanly on some builds and leave others behind.

Keep a simple record of what you find, even a spreadsheet column with the claimed version and the date you checked it. The value is in noticing drift over time: catching the profile that was fine two months ago and has quietly slipped a cycle or two behind.

None of this is a one-time setup task. Chrome ships a new stable roughly every four weeks, so the “current” version window keeps moving, and a profile that was reasonably fresh two months ago is drifting into the tail again right now. Treat it the way you’d treat patching a server: recurring, scheduled, boring, which is exactly what makes it easy to skip, and exactly why it belongs on a checklist instead of memory.

The honest bottom line

None of this makes a browser undetectable. I’m not claiming any of the tools named here are risk-free just because their Chromium base happens to be current this week. Version freshness is one weak signal among many that detection systems weigh, and fixing it doesn’t offset a burned proxy, a thin account history, or behavior that doesn’t match a real user’s. What it does is remove one cheap, easy-to-compute red flag from the pile, the kind a detection script can check in a single line of code, before it even gets to the expensive stuff.

The vendors in this category are doing real engineering work against a moving target. The lag is structural, not lazy. What’s on you is checking, on your own schedule, whether the profiles you’re actually running have drifted further behind than you’d assume. That drift happens quietly, and it compounds with everything else in a fingerprint. I test these tools hands-on because the gap between what a vendor claims and what a profile actually reports is exactly where the honest picture lives. It’s rarely where the marketing points.

If you want more of this kind of hands-on testing, breakdowns of how specific fingerprint components actually work, and honest reads on which anti-detect tools hold up under real scrutiny, you can find the rest of it on the Anti-Detect Review home page.

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

need infra for this today?