Glossary

These are the terms you meet in the docs, each with a short definition and a link to the page that explains it. They are in alphabetical order, and a colored label shows the area a term belongs to. You can link straight to a term, for example /glossary#headless.

Jump to a letter

A#

ADR#

An Architecture Decision Record: a short page that records one design decision and why it was made. The records here cover the stealth architecture, multiple drivers and Playwright, the stealth scraping layout and the plugin framework.

See ADR 001: Stealth and Fingerprinting Architecture.

Akamai fingerprint#

A string that describes how a client opens an HTTP/2 connection, written SETTINGS | WINDOW_UPDATE | PRIORITY | pseudo-header order. A site can use it, with the TLS handshake and the order of the headers, to tell clients apart.

See Wire Formats and Impersonation.

ALPN#

Application-Layer Protocol Negotiation: the part of the TLS handshake where client and server agree on HTTP/1.1 or HTTP/2. On the browser’s side, MitmProxy offers http/1.1 only.

See TLS Server and MitmProxy.

Audio noise#

A tiny, repeatable change to the audio data a page can read (AudioBuffer.getChannelData and similar), so that the audio fingerprint is not the real machine’s. With the usual settings it follows the fingerprint’s seed, so reading the same audio twice gives the same result.

See Fingerprint & Stealth Profiles.

Automation markers#

Signs that a program is driving the browser, such as navigator.webdriver, the cdc_ variables that chromedriver puts in the page and the enable-automation launch switch. UC mode masks the ones in the page and leaves out the enable-automation switch, binary patching removes the cdc_ markers from chromedriver itself, and the pure CDP engine has no chromedriver to leave any.

See Undetected (UC) Mode Guide.

B#

BaseCase#

The test case of the WebDriver engine: one object whose methods open pages, find elements by selector, click, type, wait and assert. It is the Rust version of Python SeleniumBase’s BaseCase.

See Getting Started with SeleniumBase for Rust.

Behave#

The crate’s Gherkin runner: a small parser and step runner for .feature files, like Python’s behave. You register step definitions, plain or async, and can run only the scenarios with certain tags.

See Behave / Gherkin Support.

Binary patching#

Editing a driver or browser executable on disk so that it no longer carries the markers bot checks look for, such as the cdc_ variables. ChromedriverPatcher patches chromedriver and ChromeBinaryPatcher patches a cached copy of the browser; UC mode does not patch the driver for you.

See Binary Patching.

BrowserConfig#

The settings for one browser session: which browser, the driver mode, headless or not, proxy, user agent, fingerprint, plugins and more, set with with_* methods. BrowserConfig::default() is headless and reads no environment variables.

See Public items of the crate root.

BrowserContext#

A set of tabs in the pure CDP engine that shares no cookies, storage or cache with anything else, like an incognito window. It is much cheaper than a second Chrome process, and each context can have its own proxy.

See Pure CDP.

BrowserPool#

A pool in the pure CDP engine that shares a few Chrome processes between many concurrent workers. Each acquire() gives a lease: its own isolated context and a tab.

See Pure CDP.

BrowserScraper#

A fetcher in the experimental stealth crates that drives one real Chrome through the pure CDP engine. It loads a URL, detects a challenge, solves it in the browser and rotates the egress or the profile when challenges repeat; it does no TLS spoofing.

See BrowserScraper.

Built-in plugin#

One of the official plugins that ship inside seleniumbase-rs, one Cargo feature each: shield, block-resources and crx. The prebuilt sbrs and sbrs-mcp have them compiled in, and you switch one on by name, for example sbrs --plugin shield open https://example.com.

See Choosing Plugins.

C#

Canvas noise#

A small, seeded change to the pixels a page reads from a canvas (toDataURL, toBlob, getImageData), so that the canvas fingerprint is not the real machine’s. The StealthPolicy picks the kind: seeded, a fresh seed for each document, low (one pixel in eight) or none.

See Fingerprint & Stealth Profiles.

Capability#

One thing a plugin may do, written as a stable string such as launch.args, cdp:Network or page.script:example.com. A plugin declares the ones it needs and a PluginSet grants and checks them; for a native Rust plugin this is a declared contract, not a sandbox. It is not the same as the WebDriver capabilities that with_capabilities merges into a session.

See Capabilities.

Cargo feature#

An opt-in part of the crate that you switch on with --features, such as mcp-server, tui, gui, playwright, plugins or test-util. No feature of the library is on by default, so a plain build is small.

See Building and installing.

CDP#

The Chrome DevTools Protocol: the browser’s own debugging protocol, spoken over a WebSocket. The pure CDP engine uses it alone, while CDP mode and UC mode use it next to WebDriver.

See Pure CDP: Chrome without a WebDriver.

CDP mode#

DriverMode::Cdp: a WebDriver session that also turns on CDP domains, so you can send raw CDP commands and use helpers such as cdp_click. Do not confuse it with Python SeleniumBase’s own CDP Mode (sb.cdp), which this crate provides as the pure CDP engine.

See CDP Mode Guide.

CdpReactor#

A helper that connects to a browser’s debug WebSocket, turns on the Fetch domain and continues every paused request with the headers you give it. It needs a browser started with --remote-debugging-port.

See CDP Mode Guide.

Challenge#

A page that a bot-protection service shows instead of the content you asked for: a script that must run, a widget to complete, a block or a rate limit. The stealth crates read it from the response, where a header, a widget or a bare 403 is only evidence and the verdict needs an interstitial marker, and then decide what to do next.

See Cookies, Identity and Challenges.

Chrome for Testing#

Google’s builds of Chrome and chromedriver made for automated testing. The WebDriver engine downloads the chromedriver that matches your Chrome from it, and --cft (Browser::ChromeForTesting) runs a Chrome for Testing browser, downloaded into downloaded_drivers/ when missing.

See Customizing Test Runs and Operating systems.

chrome-headless-shell#

Chrome’s old headless mode, which now exists only as a separate build. The WebDriver engine runs it as Browser::ChromeHeadlessShell (--browser chs); it is downloaded into downloaded_drivers/chs/ when missing and cannot run UC mode.

See Headless and Headed Browsers.

chromedriver#

The program that turns WebDriver commands into actions in Chrome. Its major version must match Chrome’s: sbrs install downloads the right one and sbrs doctor compares the two. The pure CDP engine needs none.

See Operating systems.

Clearance#

The cookie a site gives once a challenge is solved. It belongs to the address that earned it, so an identity may use it only through the same egress.

See Cookies, Identity and Challenges.

Client Hints#

The Sec-CH-UA* request headers and the navigator.userAgentData object through which Chrome tells a site its brand, version and platform. A Fingerprint can set them or turn them off; the user agent keeps Chrome’s frozen major.0.0.0 while the hints carry a real full version.

See Fingerprint & Stealth Profiles.

ClientHello#

The first message of a TLS handshake, in which a client says which versions, ciphers and extensions it supports. A site can tell clients apart by it, and JA3 and JA4 are summaries of it.

See Wire Formats and Impersonation.

Commander#

A terminal UI for browsing and running tests and examples, behind the Cargo feature tui. Without the feature, sbrs commander prints a hint and exits with status 2.

See SeleniumBase Commander.

Cookie jar#

The cookie store of the stealth crates. It follows RFC 6265 and the rules Chrome ships, checks domains against the Public Suffix List, and converts to and from the cookies a CDP browser reports.

See Cookies, Identity and Challenges.

crx#

The packed Chrome extension format (.crx, as CRX3 or the older CRX2). The crx plugin unpacks such files into a temporary folder and loads them into a Chromium browser that the plugin set starts; it does not check the signature in the header.

See crx Plugin.

CSS selector#

The default kind of selector: a string with none of the special prefixes is read as CSS, for example input[name='email']. An attribute selector such as [name=q] is CSS too; there is no name= prefix.

See Selectors Guide.

D#

Deferred assertion#

An assertion that checks the page at once but does not stop the test when it fails. It records the failure, and process_deferred_asserts reports all of them together. It is also called a soft assertion.

See Waits and Assertions.

Demo mode#

A run setting (RunSettings::with_demo_mode) that outlines each element before an interactive call and pauses after it, so a person can follow the test. Never leave it on in CI, because the run waits on purpose.

See Run Settings: Demo, Slow and Fast Runs.

DevTools endpoint#

The address of a running Chrome’s remote-debugging port, by default 127.0.0.1:9222, that other tools attach to. sbrs devtools starts a Chrome with one open and prints it; any program on the machine can drive a browser whose endpoint is open.

See DevTools MCP servers.

Docs7#

The documentation host that publishes these pages as a website, part of Context7. Its configuration is docs/docs.json, and its navigation follows docs/SUMMARY.md.

See Building and installing.

DriverMode#

The setting that chooses how BaseCase drives Chrome: WebDriver (the default), Cdp or Uc. The names webdriver, cdp and uc are the ones that SB_MODE and sbrs use.

See Public items of the crate root.

E#

Egress#

The exit address a request leaves through: one of your proxies, or the direct connection. Changing it (rotate_egress) opens a new browser context behind the new proxy and drops the old one with its cookies, because a clearance belongs to the address that earned it.

See BrowserScraper.

Ephemeral CA#

A certificate authority made in memory and kept only for the life of one process. MitmProxy uses one to end Chrome’s TLS. Chrome trusts the leaf certificates only through a pin of the leaf key, and the CA is never installed in a trust store or written to disk.

See TLS Server and MitmProxy.

Evasion provider#

A small unit that returns a JavaScript snippet for one thing a page can probe, such as navigator, WebGL or canvas noise. An EvasionRegistry assembles the providers, in priority order, into one script that runs before any page script.

See Fingerprint & Stealth Profiles.

F#

Fingerprint#

What a browser claims to be: user agent and Client Hints, language, time zone, screen, location and the hardware a page can probe. It holds one Spoof per setting, is built once from a preset, randomized(os, seed) or the builder, and is never changed afterwards; to_builder() makes a changed copy.

See Fingerprint & Stealth Profiles.

G#

Gherkin#

The plain-language format of .feature files, where behaviour is written as scenarios made of steps. The crate’s Behave runner reads Gherkin and matches each step to a step definition you register.

See Behave / Gherkin Support.

GREASE#

Random reserved values (RFC 8701) that a client adds to its TLS handshake so that servers do not depend on a fixed list. JA3 and JA4 leave them out, so only the peetprint shows a GREASE signature algorithm.

See Limits and Troubleshooting.

H#

HAR#

HTTP Archive 1.2: a file format that lists the requests a page made and the answers it got. In the pure CDP engine, page.start_har() records a tab and finish() returns a Har that you can save as a .har file, which browser developer tools open.

See Pure CDP.

Headed#

A browser that opens a window you can watch. Run headed when someone has to see or use the window, for recording, for clicking with the system pointer, or for sites that block headless browsers.

See Headless and Headed Browsers.

Headless#

A browser that runs without a window; it still loads pages, runs scripts and takes screenshots and PDFs. The default depends on the entry point: BrowserConfig::default() is headless, while sbrs and the settings file are headed.

See Headless and Headed Browsers.

HttpSession#

A client in the experimental stealth crates that sends plain HTTP requests carrying the cookies, the measured TLS and HTTP/2 start, the header order and the identity of a real Chrome page. It does not run JavaScript or solve challenges.

See HttpSession.

Human-paced input#

Clicks, typing and scrolling timed like a person’s: the pointer follows a curve with a bell-shaped speed, typing has uneven intervals and optional typos, and a click lands inside the element rather than on its exact centre. page.human(behavior) returns a Human that does it; it is still trusted input, only slower.

See Pure CDP.

I#

Identity#

What a session presents to a site. In the stealth crates a StealthIdentity holds the Fingerprint, a reference to the measured browser, the cookies it earned, its clearances and the egress they were earned through; it never holds a proxy, and its file is private. In the fingerprint pages, an identity is also a whole Fingerprint drawn for one seed.

See Cookies, Identity and Challenges.

Impersonation#

Making a client send the same TLS handshake, HTTP/2 start and headers as a measured browser, so a site sees that browser’s wire fingerprint. The mimic crate does it with a wreq client, and only Chrome 155 on macOS is measured today.

See Wire Formats and Impersonation.

Interstitial#

A page shown instead of the content you asked for, such as a check page. A response counts as a challenge only when it carries an interstitial marker.

See Cookies, Identity and Challenges.

J#

JA3#

A fingerprint of a client’s ClientHello: five comma-separated fields with GREASE removed, usually shown as an MD5 hash. A site can use it to tell TLS clients apart.

See Wire Formats and Impersonation.

JA4#

A newer fingerprint of a client’s ClientHello, written in three parts as a_b_c after FoxIO’s definition. JA4_r and JA4_ro are the unhashed variants, and only JA4 itself is implemented here, not the other JA4+ methods.

See Wire Formats and Impersonation.

JSON scenario#

A hand-written JSON file of steps that sbrs run-scenario --file runs, for CI smoke checks or for authors who do not write Rust. It is not the action file that sbrs record writes.

See Syntax Formats.

L#

Link text#

A selector kind that finds a link by the text people see. link=Log in matches the whole text and partial_link=Privacy part of it (short form p_link=); in the pure CDP engine a text= prefix also means link text.

See Selectors Guide.

Locator#

The pure CDP engine’s handle for finding elements. It remembers how to find them, not which element it found, so every action looks again and waits for the element, and keeps working when the page re-renders. Narrow it with .locator(), .nth(), .visible() and similar calls.

See Pure CDP.

M#

MasterQA#

A hybrid workflow that mixes automated navigation with manual checks. A test starts a session with start_qa_session, runs scripted steps, asks a person to confirm each manual step in the terminal with manual_verify, and saves a report that lists only the manual steps.

See MasterQA Guide.

MCP#

The Model Context Protocol: the way an AI agent calls a tool such as a browser. This crate ships the MCP server sbrs-mcp.

See MCP servers.

Measured profile#

Wire values copied from a real browser by capture tools and stored as JSON: its TLS spec, HTTP/2 start, header order and Client Hints. Today there is one, Chrome 155.0.8059.40 on macOS, and any other browser and system pair is refused with NotMeasured.

See Wire Formats and Impersonation.

MFA#

Multi-factor authentication: a login that asks for a second proof, here usually a TOTP code. enter_totp_code(css, secret) types the code into a field and presses Enter.

See MFA / TOTP Guide.

MitmProxy#

A loopback forward proxy in the experimental mimic crate. It ends a real Chrome’s TLS with a certificate from an ephemeral CA and replays each request through the impersonating client, so the site sees the measured handshake instead of Chrome’s own.

See TLS Server and MitmProxy.

Mock browser#

A pure CDP browser backed by a script instead of Chrome. Browser::new_mocked() (Cargo feature test-util) records every protocol command and answers it with the handler you register, so you can test what your code sends.

See Pure CDP.

N#

Native spoofing#

A StealthPolicy option (native_spoofing) that delivers a fingerprint’s claims through CDP overrides and launch arguments where the browser can, instead of through replaced JavaScript getters. The browser then reports the value itself; things the protocol cannot cover, such as WebGL and canvas noise, stay in JavaScript.

See Fingerprint & Stealth Profiles.

P#

Page#

One browser tab in the pure CDP engine. It is a cheap handle (a clone points to the same tab) for navigating, running scripts, taking screenshots and making Locators.

See Pure CDP.

Parity table#

The page that records, for every API of Python SeleniumBase 4.55.2, how this crate covers it: with an item of the same name (implemented), with other items (composed), not at all because there is nothing to port (not-applicable), or not yet (planned).

See API parity with Python SeleniumBase.

peetprint#

A JA3-like TLS fingerprint that also records the signature algorithms, and shows GREASE as GREASE.

See Wire Formats and Impersonation.

Persona#

The whole machine and place that a Fingerprint pretends to be: operating system, hardware, locale, time zone and position. A randomised identity draws the persona first and derives every field from it, so the signals agree with each other.

See Fingerprint & Stealth Profiles.

Playwright mode#

An optional engine, behind the Cargo feature playwright, that uses rustwright to drive Chromium with a Playwright-compatible API. activate_playwright_mode starts it as a second Chromium next to the WebDriver one.

See Playwright Mode.

Plugin#

A browser plugin is a Rust crate that changes how a browser starts and what every tab gets, through hooks (before_launch, on_browser, on_page_created and on_close). You add it to a PluginSet and give the set to the launch options; it is not a test plugin, which runs around a test.

See Browser Plugins.

PluginSet#

The plugins a program uses, with the capabilities each was granted. It checks them against the browser about to start, orders them and calls their hooks.

See PluginSet.

Pure CDP#

The engine in sb_cdp that drives Chrome directly over the DevTools Protocol, with no chromedriver and none of the markers a WebDriver leaves in the page. Its main types are Browser, Page and Locator, and it is the engine behind the cdp MCP server.

See Pure CDP: Chrome without a WebDriver.

Q#

QUIC#

The UDP-based transport that carries HTTP/3. A StealthPolicy can force it off (--disable-quic), force it on (--enable-quic) or leave it to Chrome.

See Fingerprint & Stealth Profiles.

R#

Recorder#

A tool that captures your clicks, typing and navigations in a browser and turns them into a JSON action file or a Rust test. sbrs record URL -o actions.json records and sbrs replay runs the file again; from code, BaseCase records the actions it performs.

See Recorder Mode Guide.

Request interception#

Pausing every request a page makes and answering it by the first matching rule: block it, serve a made-up response or send it on with changes. In the pure CDP engine this is page.intercept(rules), and other tabs are not affected.

See Pure CDP.

Reuse session#

A run option (with_reuse_session(true), --reuse-session or SB_REUSE_SESSION) that keeps a browser open from one test to the next. The browser is cleaned before the next test gets it, and only one test holds it at a time.

See Customizing Test Runs.

RTK#

A command proxy that shortens the output of cargo, git and test runners before it reaches an AI assistant, for example rtk cargo test. Exit codes are unchanged, and it is optional.

See Build from source.

RunSettings#

Run-wide settings as plain data, the Rust version of Python SeleniumBase’s pytest options such as --demo, --slow and --message-duration. Build one and give it to BrowserConfig::with_run_settings or BaseCase::set_run_settings; the default changes nothing.

See Run Settings: Demo, Slow and Fast Runs.

rustwright#

The native Rust CDP engine behind Playwright mode. It drives Chromium with a Playwright-compatible API and needs no Node driver.

See Playwright Mode.

S#

sbrs#

The command-line tool of the crate (package seleniumbase-rs-cli): open pages, run smoke tests, send CDP commands, patch binaries, record and replay, convert Python scripts and more. Global options such as --uc, --headless and --browser go before the subcommand.

See CLI Usage (sbrs).

sbrs doctor#

A diagnostic check of the environment and configuration. Among other things it compares the chromedriver version with Chrome’s.

See sbrs doctor.

sbrs install#

Downloads a driver into ./downloaded_drivers/, in practice the chromedriver that matches your Chrome. sbrs get is another name for it.

See sbrs install.

sbrs-mcp#

The MCP server program. It lets an AI client drive a browser over standard input and output, with one of three toolsets chosen by --server: cdp (pure CDP), driver or sb (the default). It opens no network port.

See MCP servers.

Selector#

The text that says which element you mean. BaseCase reads its start: # is an ID, . a class, / or // begins XPath, link= is link text, and anything else is a CSS selector.

See Selectors Guide.

SelectorBuf#

The owned selector type of the pure CDP engine, the twin of the borrowed Selector that BaseCase uses. SelectorBuf::css and xpath state the kind outright, and containing_text finds elements by their text.

See Pure CDP.

Selenium Grid#

A hub that sends tests to browsers on other machines. sbrs grid starts a hub or node from a Selenium Server jar that you supply, and BrowserConfig::webdriver_url points a test at the hub; only the WebDriver engine can use it.

See Deployment.

seleniumbase-rs-stealth#

The separate, experimental repository that holds the TLS and HTTP/2 layer as three crates: codec (wire formats), scrape (BrowserScraper, identity, challenge detection) and mimic (HttpSession, MitmProxy, StealthSession). It left this crate in 0.3.0.

See Stealth Scraping.

Settings#

The layers that configure a run, where a later one wins: built-in defaults, the sbase_config.toml file, SB_* environment variables and a BrowserConfig built in code. sbrs flags override the file and the variables for the commands it runs.

See Settings and Global Configuration.

Shadow DOM#

A tree of elements hidden inside a web component. BaseCase searches inside open shadow roots with the ::shadow combinator, as in my-app ::shadow button; only open shadow roots can be reached.

See Shadow DOM Guide.

Slow mode#

A run setting (RunSettings::with_slow_mode) that pauses after interactive calls as demo mode does, but without outlining the element.

See Run Settings: Demo, Slow and Fast Runs.

SNI#

Server Name Indication: the host name a client states in its TLS handshake. MitmProxy refuses a connection whose SNI names a different host from the one the browser asked for.

See TLS Server and MitmProxy.

Soft assertion#

Another name for a deferred assertion: a check that records its failure instead of stopping the test.

See Waits and Assertions.

Spoof#

One setting of a Fingerprint, which is in one of four states: Natural (the browser’s own value, the default), Random (a coherent value drawn when the fingerprint is built), Value (exactly what you give) or Off (the API is turned off, only where that makes sense, such as geolocation or WebRTC). The state and the value are one field, so they cannot disagree.

See Fingerprint & Stealth Profiles.

Stale element#

An element found earlier whose part of the page was later replaced, so the old handle no longer works. Find the element again before each action; a Locator does that for you.

See Selectors Guide.

StealthPolicy#

How a Fingerprint’s claims are delivered and which protections run beside them, such as the WebRTC leak policy, canvas noise, audio noise and the window.chrome stubs; it never changes what a setting claims. The presets are default() (only the toString mask and open shadow roots), balanced(), native_only() and max().

See Fingerprint & Stealth Profiles.

StealthSession#

A session in the experimental mimic crate that presents one identity in two modes: plain HTTP through an HttpSession, or a real Chrome behind a MitmProxy. When a challenge appears in HTTP mode it moves to the browser, solves it there, and returns to HTTP with the clearance.

See StealthSession.

T#

Tauri#

A framework for desktop apps that draw their window with the system webview. The Tauri plugin runs a small W3C WebDriver endpoint inside your app, so BaseCase and sbrs can test its real window on macOS, Windows and Linux.

See Tauri Plugin.

Test plugin#

Code that runs around a test: when it starts, when it fails (with the browser still open, so it can take evidence) and when it finishes. The bundled ones save a screenshot and the page source on failure and write reports; they are not browser plugins.

See Test Plugins.

thirtyfour#

The Rust WebDriver client library that the WebDriver engine is built on. Selectors become thirtyfour::By values, and elements are thirtyfour::WebElement handles.

See How it compares.

TokenSave#

A code graph of the repository that an AI assistant asks for symbols, callers and the impact of a change, instead of searching and reading whole files. It is optional: run tokensave init in your checkout.

See Build from source.

TOTP#

Time-based one-time password: a short code worked out from a shared secret and the current time. get_totp_code(secret) returns it from a base32 secret (RFC 6238 with HMAC-SHA1, a 30 second step and 6 digits).

See MFA / TOTP Guide.

Tour#

A guided walkthrough of a page, drawn as HTML overlays by a JavaScript tour library. You build it in a test with create_tour_with_theme, add_tour_step and export_tour, and the exported file is standalone HTML that you open in a browser.

See Interactive Tours Guide.

Trusted input#

Input sent through the DevTools Protocol, which the page sees as trusted events, as it sees a person’s input. In the pure CDP engine, clicks and key presses are trusted input.

See Pure CDP: Chrome without a WebDriver.

U#

UC mode#

Undetected mode (DriverMode::Uc, or sbrs --uc): it starts Chromium with undetected-Chrome launch arguments, leaves out the enable-automation switch and injects a stealth script into every new document. It needs Chrome, Chromium or Edge, and it does not patch chromedriver for you.

See Undetected (UC) Mode Guide.

User agent#

The string a browser sends to say what it is. A headless Chrome reports HeadlessChrome instead of Chrome, and a Fingerprint can set the user agent together with matching Client Hints.

See Headless and Headed Browsers.

W#

wasm plugin#

A plugin written in any language that compiles to WebAssembly, loaded with the seleniumbase-rs-plugin-wasm crate. The host reads its data once (a name, browser switches, page scripts and URL patterns to block), checks every value and drops the module, which has no imports; it is the only kind of plugin that is sandboxed.

See wasm Plugin Host.

WebDriver#

The Selenium protocol: the test talks to chromedriver (or another driver), which drives the browser. The WebDriver engine (BaseCase) is the one to use for Selenium Grid, Firefox or an existing SeleniumBase-style suite.

See Performance.

WebRTC leak#

A page can open an RTCPeerConnection without asking, and the candidates it gathers describe the machine’s network, which is how a proxy or VPN gets bypassed. In the pure CDP engine the WebRTC shield makes every connection relay-only, and the shield plugin and a fingerprint’s WebRTC settings limit what a page can learn.

See Pure CDP.

Wire fingerprint#

What a site can tell about a client before any page script runs: the TLS ClientHello, the HTTP/2 connection start, and the order and spelling of the request headers.

See Stealth Scraping.

X#

XPath#

A selector language that walks the document tree. A selector that starts with /, //, ./, ../ or (, or with an axis such as parent::, is read as XPath, and xpath_to_css converts only simple expressions to CSS.

See Selectors Guide.

Xvfb#

A virtual X display: a headed browser can open its window on it when the machine has no screen. On Linux BrowserConfig::with_virtual_display starts one for the WebDriver engine, and the Xvfb program must be installed.

See Headless and Headed Browsers.

Related reading#