Fingerprint & Stealth Profiles

Websites detect automation by looking at many browser signals: navigator.webdriver, user agent, platform, screen size, hardware concurrency, WebGL vendor, canvas noise, audio noise, time zone, geolocation, media devices, fonts, and more. seleniumbase-rs can spoof these signals through a coherent Fingerprint and a pluggable evasion system.

This page explains how to use built-in fingerprint presets, build custom profiles, say per setting whether the browser’s own value, a drawn value, a given value or nothing is wanted, choose how the claims are delivered, and apply native-level spoofing through CDP. It covers what a page can read inside the browser. The TLS and HTTP/2 side, and the scraper built on it, is a separate project now; see Stealth Scraping.

Quick start#

use seleniumbase_rs::{BaseCase, BrowserConfig, DriverMode, Fingerprint};#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let fp = Fingerprint::windows_desktop();    let config = BrowserConfig {        mode: DriverMode::Uc,        fingerprint: Some(fp),        ..BrowserConfig::default()    };    let mut sb = BaseCase::new(config).await?;    sb.open("https://example.com").await?;    sb.quit().await?;    Ok(())}

A fingerprint reaches the page only through a launch path that applies it:

• With DriverMode::Uc (above) or DriverMode::Cdp, the session registers the evasion script and sends the protocol overrides described under Native-level (CDP) spoofing, and the launch arguments apply. The script is the one the Pure CDP engine runs, evasions::session_script (the 27 providers of session_registry); see Built-in providers.
• With the default DriverMode::WebDriver, only the launch arguments apply (user agent, --lang, --window-size, the WebRTC policy, and the QUIC and proxy flags). No script is injected and no protocol override is sent.
• The Pure CDP engine and the Playwright session have their own paths, described below. The Pure CDP engine runs the same session_script. The Playwright session runs bootstrap_script, the 29 providers of default_registry.

One setting, four states#

Every setting of a fingerprint is one Spoof, and the state says everything about it. The value and the intent are one field, so they cannot disagree.

build() returns an error that names the setting when Off is given to any other, so a time zone cannot be “off” by accident.

use seleniumbase_rs::stealth::fingerprint::{CanvasNoise, Fingerprint, Spoof, StealthPolicy};let fp = Fingerprint::builder()    .timezone("Europe/Berlin")    .screen(1920, 1080)    .geolocation(Spoof::Random)    .webrtc(Spoof::Off)    .policy(StealthPolicy::balanced())    .canvas_noise(CanvasNoise::Random)    .build()?;# Ok::<(), seleniumbase_rs::stealth::fingerprint::FingerprintError>(())

The random position is a spot in Berlin, because the time zone is a Value.

A built fingerprint is never changed. Its fields are private and are read through accessors (fp.timezone() returns &Spoof<String>); to change one, start a builder from it:

use seleniumbase_rs::Fingerprint;let fp = Fingerprint::windows_desktop();let tokyo = fp.to_builder().timezone("Asia/Tokyo").build()?;assert_eq!(tokyo.timezone().as_str(), Some("Asia/Tokyo"));# Ok::<(), seleniumbase_rs::stealth::fingerprint::FingerprintError>(())

Fingerprint presets#

Built-in presets set a coherent combination of user agent, platform, screen, WebGL strings, a time zone, and the policy StealthPolicy::balanced():

Every preset also carries a battery, network information, the speech voices of its system and Web Bluetooth (where its browser has them). It leaves the position Natural on purpose: a position is answered without a prompt, and a fresh browser answers permissions.query for geolocation with prompt, so a preset that claimed one would stand out. validate() warns about a time zone without a position only when the policy grants permissions, which hands pages the real position. All six presets validate without errors or warnings; tests/mcp_webdriver.rs and the unit tests of stealth::fingerprint check it. A preset holds no Random, so it is the same every time and its canvas noise is the same on every launch.

Use the fingerprint! macro for shorter syntax. safari is an alias for ios, and edge is the Edge preset:

use seleniumbase_rs::fingerprint;let fp = fingerprint!(windows);let fp = fingerprint!(edge);let fp = fingerprint!(macos);let fp = fingerprint!(linux);let fp = fingerprint!(android);let fp = fingerprint!(ios);let fp = fingerprint!(safari); // same as ios

Randomised identities#

A preset is one identity; a fleet of sessions that all share it is easy to spot. Fingerprint::randomized(os, seed) generates a different, believable identity for each seed instead. It is the builder with the settings of a persona set to Random, so you can draw the same way for any setting yourself:

use seleniumbase_rs::{Fingerprint, OsType};let fp = Fingerprint::randomized(OsType::Windows, 42);// The same seed always gives the same identity.assert_eq!(fp, Fingerprint::randomized(OsType::Windows, 42));// It passes the coherence check, with no warnings either.let report = fp.validate();assert!(report.is_coherent() && report.warnings.is_empty());// Another seed is another identity.let other = Fingerprint::randomized(OsType::Windows, 43);assert_ne!(fp, other);

Detectors check that signals agree with each other, so the generator never randomises a field alone. It draws a whole machine and a whole place, then derives every field from them:

All five OsType values are supported, with StealthPolicy::balanced().

Things to know:

• Stable within a release. A seed maps to the same identity for one version of the crate. Adding a table row changes what a seed maps to, so store the generated Fingerprint (it is Serialize), not the seed, if an identity has to outlive an upgrade.
• The Chromium version is a fixed window. At this version of the crate the user agent claims Chromium 154, 155 or 156 (an iPhone identity claims Mobile Safari 18.1, 18.3.1, 18.5 or 26.0; Safari 26 names the frozen iPhone OS 18_6 in its user agent). Pair the identity with a browser of that era, or change user_agent, client_hints and core_version together. Fingerprint::randomized_with_major(os, seed, major) fixes the Chromium major instead (Safari and iOS ignore it), and so does .core_version(major) on a builder that draws a user agent or Client Hints; the stealth scraper of seleniumbase-rs-stealth uses it so the identity claims the Chrome that is running (see Stealth Scraping).
• iOS differs. Safari has no navigator.deviceMemory and no navigator.userAgentData, so an iOS identity leaves device_memory Natural and turns client_hints Off.
• Client Hints carry a real full version. The user agent keeps Chrome’s frozen major.0.0.0, but uaFullVersion and fullVersionList name a real build from randomize::KNOWN_FULL_VERSIONS: 154.0.8037.100 and 156.0.8078.35 from Google’s published stable releases, and 155.0.8059.40 as Chrome 155 reported it on a Mac (tests/client_hints_chrome.rs). A major the table does not list (one forced with randomized_with_major) falls back to major.0.0.0.
• Platform versions. A Mac claims macOS 15.8.1, 26.7.1, 27.0.0 or 27.0.1, in the major.minor.patch form Chrome reports (27.0.1 was read from Chrome 155 on macOS 27.0.1). The Windows list (10.0.0, 13.0.0, 15.0.0, 19.0.0) follows Microsoft’s description of the value and was not read from a Windows Chrome.
• Not drawn by randomized: fonts, media devices and WebRTC addresses. Ask for them with Spoof::Random on a builder; the proxy has no random value.
• Applying it. For the Pure CDP engine, hand it to the launch options with LaunchOptions::builder().fingerprint(&fp) (see Pure CDP); page.apply_fingerprint(&fp) does the same for one tab. For BaseCase, pass it to BrowserConfig::with_fingerprint and use DriverMode::Uc or DriverMode::Cdp. You can also feed it to the evasion registry yourself.

Building a custom fingerprint#

For full control, use the builder:

use seleniumbase_rs::Fingerprint;let fp = Fingerprint::builder()    .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ...")    .platform("Win32")    .screen(1920, 1080)    .hardware_concurrency(8)    .device_memory(8.0)    .locale("en-US")    .timezone("America/New_York")    .webgl(("Google Inc. (NVIDIA)", "ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 ...)"))    .geolocation((40.7128, -74.0060))    .media_device_counts(1, 1, 2) // audio inputs, audio outputs, video inputs    .build()?;# Ok::<(), seleniumbase_rs::stealth::fingerprint::FingerprintError>(())

There is no flag to flip afterwards, and none to set. Giving a value is the intent to use it, so the fingerprint above masks its navigator, language, screen, WebGL, time zone, position and media devices. Fingerprint::is_masked(Dimension) is the one question the page-script providers, the launch arguments, the protocol overrides and the proxy all ask, so a value is never half applied (a user agent sent to the browser but not to the page, say).

The settings#

Every setter takes impl Into<Spoof<T>>. screen(width, height) is the common case of screen_spoof. A tuple is the value of geolocation ((lat, lon)), webgl ((vendor, renderer)), webrtc ((public_ip, local_ip)), avail_screen and media_devices ((audio_in, audio_out, video_in)).

A Natural setting changes nothing, so the providers define only the values the fingerprint holds.

How Random stays coherent#

build() works out the operating system (the explicit one, else the one the user agent names, else Windows), then the place: the region of a given time zone, else of a given locale, else a drawn one. Every Random setting is taken from one seeded draw of that machine and that place, so:

• a random locale agrees with a given time zone, and a random time zone with a given locale;
• a random position is in the main city of that time zone;
• a random graphics adapter is one the operating system reports, and random Client Hints name the Chromium major the user agent names.

When nothing coherent can be drawn (a random locale next to a time zone the table of places does not know), build() returns a FingerprintError that says which setting and why. .seed(u64) makes the draw repeatable. Without it the draw uses fresh entropy, and the seed it used is kept in the fingerprint (fp.seed()), so fp.to_builder().build() reproduces it.

build() also fills two values the caller left out: languages, from a given locale (the table’s list for a known locale, else the locale and its language), and navigator.platform and the operating-system persona, from a recognised user agent. A value you set is never replaced.

The policy#

A setting is what the browser should claim. The StealthPolicy is how the claims are delivered and which protections run beside them. It has no say over a claim: a preset policy never changes a setting’s state, and the two can be given in any order.

use seleniumbase_rs::stealth::fingerprint::{CanvasNoise, Fingerprint, StealthPolicy};let fp = Fingerprint::builder()    .canvas_noise(CanvasNoise::Low)        // a shortcut, applied after the base...    .grant_permissions(true)    .policy(StealthPolicy::balanced())      // ...whatever the order    .with_policy(|p| p.disable_csp(true))   // any change, in order    .build()?;assert!(fp.policy().chrome_runtime && fp.policy().disable_csp);# Ok::<(), seleniumbase_rs::stealth::fingerprint::FingerprintError>(())

StealthFlags is a deprecated alias of StealthPolicy, kept for one release.

Fingerprints as JSON#

A Spoof is written as "natural" (and left out), "random", "off" or the value itself; null reads as Natural. A fingerprint that holds "random" is drawn when it is read, the same way build() does it, so give a seed for a repeatable file. A field this version does not know, such as the flat screen_width of the old shape, is an error and not a silent loss. Battery times that are infinite (discharging_time of a charging battery) are written as null.

Native-level (CDP) spoofing#

When a session has a CDP connection (DriverMode::Uc, DriverMode::Cdp, or the Pure CDP engine), a fingerprint is applied in two layers:

1. The evasion script, assembled from the providers below and registered with Page.addScriptToEvaluateOnNewDocument. Page scripts can in principle detect a JavaScript patch through Function.prototype.toString, Object.getOwnPropertyNames, or descriptor inspection, which is why the providers use the sb helpers to look native.
2. The protocol overrides from evasions::safe_cdp_overrides. (The older evasions::cdp_overrides is deprecated: it also holds the Proxy-Authorization header that would hand the proxy’s login to every site.) A command is sent for a setting that holds a value, so a Natural setting sends nothing:

So a UC or CDP session already gets these overrides without native_spoofing, and the JavaScript providers patch the same properties on top of them. native_spoofing makes the providers stand down where a protocol override covers the property, so the browser reports the value itself instead of a replaced JavaScript getter:

use seleniumbase_rs::Fingerprint;let fp = Fingerprint::builder()    .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 …")    .platform("Win32")    .screen(1920, 1080)    .locale("en-US")    .timezone("America/New_York")    .geolocation((40.7580, -73.9855))    .native_spoofing(true)    .build()?;# Ok::<(), seleniumbase_rs::stealth::fingerprint::FingerprintError>(())

When native_spoofing is true:

• navigator_props leaves out platform, userAgent and appVersion (a given app_version is still scripted).
• window_geometry emits only colorDepth and pixelDepth; the size and scale come from Emulation.setDeviceMetricsOverride.
• localization, timezone, the JavaScript geolocation provider that answers a position, and client_hints are skipped. A denied geolocation (Off) is still scripted: no protocol command denies the request for one tab.
• The JS providers stay for everything the protocol does not cover: hardwareConcurrency, deviceMemory, maxTouchPoints, vendor, WebGL vendor and renderer, canvas and audio noise, media devices, fonts, battery, connection, speech, Bluetooth, the navigator.webdriver getter and the marker cleanup.
• A WebDriver session (Chrome, Chromium or Edge) also launches a patched copy of the browser. If BrowserConfig::browser_binary_path is unset, the session finds the system Chrome (SB_CHROME_BIN, else find_system_chrome()), writes a patched copy through ChromeBinaryPatcher with EnginePatch::chrome_binary() (webdriver markers, navigator.webdriver assignments and the HeadlessChrome user-agent marker), and sets browser_binary_path to it. It returns an InvalidConfig error naming SB_CHROME_BIN if no Chrome is found. A browser_binary_path that is already set is used as it is and is not patched; that includes the one BrowserConfig::from_env() takes from SB_CHROME_BIN.

Caveats#

rustwright / Playwright mode#

This mode needs the playwright Cargo feature (rustwright); it is not on by default.

use seleniumbase_rs::browser::playwright::PlaywrightSession;use seleniumbase_rs::{BrowserConfig, Fingerprint};# async fn demo() -> Result<(), seleniumbase_rs::SeleniumBaseError> {let fp = Fingerprint::windows_desktop();let config = BrowserConfig::default()    .with_headless(false)    .with_fingerprint(fp);let session = PlaywrightSession::launch_with_config(&config).await?;session.goto("https://example.com").await?;session.close().await?;# Ok(())# }

BrowserConfig::default() is headless; .with_headless(false) opens a window. (launch_with_fingerprint and launch_headless_with_fingerprint are deprecated shortcuts for this.) The session passes the fingerprint’s launch arguments, then evaluates the evasion script in the first page and again after every goto and new_page, because rustwright cannot register a script to run in each new document.

External profile payloads#

The profile_payloads::ProfileParams type maps to a Fingerprint via ProfileParams::to_fingerprint(). ProfileParams::to_browser_config(webdriver_url) returns a BrowserConfig with that fingerprint attached.

The returned mode follows the payload’s automation field: playwright and puppeteer give DriverMode::Cdp; selenium (the default when the field is absent) and the Firefox browser types give DriverMode::WebDriver; anything else gives DriverMode::Uc. The script and protocol overrides are applied only in Cdp and Uc mode, so a payload that keeps selenium is launched with the launch arguments only. The payload’s cmd_params become Chrome flags, except switches that run a program, load an extension, set the profile directory, a proxy or remote debugging, or ignore certificate errors; those are refused. The Pure CDP engine does not pass cmd_params at all.

The payload keeps its own format, because other tools write it: the flags are strings (ProfileFlags) and the nested sections (navigator, screen, …) hold values. Every key reads the same words and ends in one of the four states of a Spoof. The profile’s folder_id and name seed the draws, so a profile gets the same drawn values on every launch, and its core_version is the Chromium major that a drawn user agent and drawn Client Hints claim (not for the Firefox and Safari personas, whose core is not a Chrome version).

Words every key reads#

Keywords are case-insensitive. A flag the payload leaves out is auto. The table below is the one place that lists the words and the literal format of each key; this is what the groups of words do:

• The natural words give the browser’s own value, whatever values the payload holds for it.
• auto (or no flag) gives the value the payload holds for the setting, and the browser’s own where it holds none.
• The mask words give the value the payload holds, and a coherent drawn one where it holds none.
• The off words turn the API off. Only where an API can be off (geolocation, WebRTC, media devices); for any other key they are read as Natural, and logged.
• A literal is the value, in the format of its key. The other settings of the same key then follow the mask words: a held value, else drawn.

An unknown keyword is logged and read as Natural. So is a literal that is not in the format of its key (wibble for a time zone, a user agent that does not open with Mozilla/ and a digit). It is never guessed at: it used to switch the dimension on and fill it with generic values.

Keywords in JSON payloads#

One table for every key. The first row says what the words mean; each later row names only what the key adds or does differently, and the literal formats it reads.

The audio, canvas, ports and QUIC keys set the policy and not a setting, so their “states” are the values of the policy field in the same columns. graphics_noise and startup_behavior are accepted and ignored. The booleans disable_csp, grant_permissions and native_spoofing set the same fields of the policy.

The settings of one key follow the word together: navigator_masking: "mask" with a navigator section that gives a user agent, a platform and a core count keeps those three and draws the memory, the touch points and the vendor, in the same machine. A key whose draw cannot be made (a random locale next to a time zone the table of places lacks) is logged and left Natural.

A literal in a flag is the value for the setting it names (the Value column above). A section of the payload that gives the same setting wins over a literal, and a section value that is an empty string is a value the payload does not give. What the browser is launched with (to_browser_config) and what the runtime overrides set (apply_runtime_overrides) are the built fingerprint’s: a natural flag launches without a --user-agent, a locale or a proxy, whatever the payload holds.

webrtc_masking also sets the IP-handling policy that keeps WebRTC from leaking the real address: every word but the natural ones passes disable_non_proxied_udp (including a payload that says nothing), public_only passes default_public_interface_only, and a literal address passes default_public_and_private_interfaces.

Payloads from older versions#

A payload written for an older version loads unchanged, with the words above. The differences you can see: an absent flag is auto (it was mask for the navigator, localization, time zone, graphics, fonts, screen, geolocation and WebRTC flags, which filled in generic values nobody asked for); off and disabled turn geolocation, WebRTC and media devices off instead of leaving them natural; an unknown word is Natural instead of mask.

Provider architecture#

Every evasion is an EvasionProvider: a small, self-contained unit that returns a JavaScript snippet for an EvasionContext (the session fingerprint plus a deterministic seed and runtime config). Providers are held by an EvasionRegistry and assembled into a single bootstrap script in priority order (lower priority() runs first). The script is one function; each snippet sits in its own try/catch, after a // provider: <name> comment. EvasionConfig turns either of those off.

use seleniumbase_rs::{default_registry, EvasionContext, Fingerprint};let fp = Fingerprint::windows_desktop();let ctx = EvasionContext::new(&fp);            // seed derived from the fingerprintlet script = default_registry().bootstrap(&ctx);assert!(script.contains("webdriver"));

evasions::bootstrap_script(&fp) is a thin wrapper over default_registry().bootstrap(&EvasionContext::new(&fp)), so existing callers keep working while new evasions are added centrally. evasions::session_script(&fp) is the same over session_registry, the script a browser session runs.

Adding your own evasion#

use seleniumbase_rs::{default_registry, EvasionContext, EvasionProvider, Fingerprint};struct HidePrint;impl EvasionProvider for HidePrint {    fn name(&self) -> &str { "hide_print" }    fn priority(&self) -> i32 { 140 }    fn script(&self, _ctx: &EvasionContext) -> Option<String> {        Some("window.print = function() {};".to_owned())    }}let mut registry = default_registry();registry.register_provider(Box::new(HidePrint));let fp = Fingerprint::windows_desktop();let script = registry.bootstrap(&EvasionContext::new(&fp));assert!(script.contains("hide_print"));

See Contributing for adding a built-in provider.

Built-in providers#

default_registry() registers 29 providers, listed here in execution order. “Runs when” is the provider’s applies condition. A dimension “is on” when Fingerprint::is_masked says so: a setting that belongs to it is not Natural, or, for the dimensions without a setting of their own, the policy switches it on (see One setting, four states).

The Pure CDP engine and the WebDriver Uc and Cdp modes do not use default_registry(). They use evasions::session_script(&fp), which is session_registry(&fp): the same list without plugins and connection (SESSION_OMITTED_PROVIDERS), which is 27 providers. A real Chrome already has navigator.plugins, navigator.mimeTypes, navigator.connection and the PDF viewer flag, and answers for them itself, so a replaced getter is one more thing a page can find that a real Chrome does not have. The assembled session script never mentions plugins, mimeTypes, pdfViewerEnabled or connection. default_registry() is unchanged, for callers that want those spoofs, such as a browser that really lacks them, and it is what evasions::bootstrap_script and the Playwright session use.

List them at runtime with default_registry().provider_names() (all 29, including the two reserved ones), session_registry(&fp).provider_names() (the 27 a browser session runs), applicable_names(&fp) (those that run for a fingerprint), or over MCP with the list_evasion_providers tool, which lists the session ones.

Profile coherence validation#

Fingerprint::validate() returns a CoherenceReport with errors and warnings; is_coherent() is true when there are no errors. Only values that were given are checked: a Natural setting is the browser’s own.

It reports an error for:

• a navigator.platform that does not fit os_type (a macOS user agent with a Win32 platform), and a user agent with no token for os_type;
• a screen with a zero dimension;
• a WebGL renderer from another operating system’s graphics API: Direct3D off Windows, Metal or an Apple GPU off macOS and iOS, Mesa off Linux, and Adreno, Mali or PowerVR off Android;
• a MobileSafari persona whose user agent has a Chrome/ token.

It reports a warning for:

• a mobile user agent with maxTouchPoints == 0, and a desktop user agent with touch points;
• a locale that differs from the first of languages;
• a time zone with no geolocation (a geolocation that is Off is a choice, and does not warn);
• a locale from another country than the time zone, judged with the table of places randomize::LOCALES (a zone the table does not hold, or a locale with no region, is not judged).

It does not look at hardware.

use seleniumbase_rs::Fingerprint;let report = Fingerprint::windows_desktop().validate();assert!(report.is_coherent() && report.warnings.is_empty());for warning in &report.warnings {    eprintln!("warning: {warning}");}

The MCP validate_fingerprint tool returns the same report for one of the six built-in presets (windows, edge, macos, linux, android, ios); it does not take an arbitrary fingerprint.

tests/fingerprint_randomized.rs asserts that Fingerprint::randomized gives no errors and no warnings for every OS, for seeds 0 to 1499 and ten edge seeds (0, u64::MAX, 1 << 63 and others). If you edit a generated profile with to_builder(), run validate() again afterwards.

Humanized input#

Detectors look for input that is too regular. The stealth::behavior module plans input that is not: curved pointer paths with a bell-shaped speed profile, Fitts’s-law timing, tremor and overshoot, and Gaussian typing with word and sentence pauses. It is pure and seedable:

use seleniumbase_rs::sb_cdp::Point;use seleniumbase_rs::stealth::behavior::{Behavior, Humanizer};# fn main() -> Result<(), seleniumbase_rs::SeleniumBaseError> {let mut person = Humanizer::new(Behavior::builder().typing_wpm(70.0).seed(7).build()?);let path = person.mouse_path(Point::new(0.0, 0.0), Point::new(200.0, 90.0), 60.0);let keys = person.typing_plan("hello");assert_eq!(path.last().map(|step| step.at), Some(Point::new(200.0, 90.0)));assert_eq!(keys.len(), 5);# Ok(())# }

To play a plan out on a page, use page.human(behavior) from the Pure CDP engine (see Pure CDP). BaseCase::human_type uses the same typing model, taking its pace from Fingerprint::humanize() when the configuration has a fingerprint.

Behavior::from_config(fingerprint.humanize()) turns a fingerprint’s HumanizeConfig (its minimum and maximum keystroke delay) into the matching behaviour.

What is spoofed#

With a CDP session and the balanced() policy (see the provider table for the conditions), for the values the fingerprint holds:

• navigator.webdriver reads false, and known automation hooks are deleted
• navigator.userAgent, platform, hardwareConcurrency, deviceMemory, maxTouchPoints, vendor, language and languages
• window.chrome.app, csi, loadTimes and runtime stubs
• navigator.plugins and navigator.mimeTypes (bootstrap_script and the Playwright session; the session script leaves them to Chrome)
• navigator.permissions.query for notifications
• screen.width, height, availWidth, availHeight, colorDepth, outerWidth, outerHeight and devicePixelRatio
• WebGL UNMASKED_VENDOR_WEBGL and UNMASKED_RENDERER_WEBGL
• Canvas toDataURL, toBlob and getImageData noise
• Audio noise (when the policy’s audio_noise is not Natural, which balanced() and so every preset and every randomized identity set)
• navigator.mediaDevices.enumerateDevices (when media_devices is a value)
• Time zone, through Intl.DateTimeFormat, the local-time methods of Date, and Emulation.setTimezoneOverride
• Geolocation, through Emulation.setGeolocationOverride, the JavaScript provider, and the geolocation permission
• $cdc_, __webdriver, __selenium and similar marker properties
• Battery Status, Speech Synthesis, and Bluetooth APIs, and Network Information (the last only in bootstrap_script)
• Client Hints (navigator.userAgentData), when client_hints is a value and the page is a secure context; Off removes it, as it removes getBattery, navigator.connection, navigator.bluetooth and WebRTC
• matchMedia answers and page visibility, canPlayType for MP4/AAC/MP3, and attachShadow roots forced open
• STUN and TURN servers dropped from RTCPeerConnection configs, and Chrome’s WebRTC IP-handling flag
• Launch arguments such as --disable-blink-features=AutomationControlled
• Optionally (native_spoofing), fewer properties replaced in JavaScript, and a patched Chrome binary for WebDriver sessions

Complementary defenses#

Runtime fingerprints work best when the browser also hides engine-level automation markers:

• Patch the chromedriver binary with ChromedriverPatcher (for example ChromedriverPatcher::new(path).patch(EnginePatch::all())?) to remove injected cdc_ and __webdriver signatures. See the Binary Patching tutorial.
• Pass the extra Chromium flags returned by engine_spoofing_args() (a Vec<String>) through BrowserConfig::with_extra_args, which replaces the list (push_extra_arg adds one), or through StealthOptions::extra_args.
• Combining a Fingerprint, UC mode, binary patching, and engine args covers the most layers this crate offers. None of it guarantees that a given detector passes.

Limitations#

Troubleshooting#

This page was brought up to date with the change that makes a setting one Spoof and moves the behaviour into the StealthPolicy by reading src/stealth/**, src/sb_cdp/{identity,launch}.rs, src/browser/{config,session,playwright}.rs, src/profile_payloads/**, src/mcp/stealth.rs and src/macros.rs again. The code examples were compiled against that source as a test of the crate; the tables were checked against the applies conditions of the providers.