Botright: Automation Scope and Privacy Boundaries
What Botright configures around Playwright, which state belongs to its client and browser, and how public source changes the privacy assessment.
BotBrowser Team
Want the structured docs for Fingerprint?
This article lives in the editorial library. For step-by-step setup, reference material, and ongoing updates, jump into the docs section.
Botright is a Python automation package built around Playwright and an installed Chromium-based browser. It can choose a browser executable, assemble launch settings, wrap context operations and add its own network requests and response storage. That is more than a page helper, but it does not make the package itself the browser engine. The practical question is which component owns a changed setting, a retained response or an unexpected connection.
BotBrowser documents profile-backed controls in its browser engine and a framework-less --bot-script interface. Those capabilities address browser configuration and automation setup. BotBrowser does not determine an application's access decisions or erase information already retained by the application, a proxy provider or another service.
TL;DR
- The Botright source examined selects an installed browser and passes settings to Playwright's persistent-context launcher. The package, driver, executable and profile directory remain distinct inputs.
- Initialization can do work before a destination page opens, including dependency setup and public IP/geographic lookups. Browser-only traffic records cannot establish the complete client data flow.
- Optional response reuse uses a cache owned by the Botright client and indexed by URL in the inspected implementation. Separate browser contexts do not, by themselves, describe that Python-side cache's ownership.
- Some documentation defaults differ from the pinned source. An operational explanation needs the actual package version and effective options, not an assumed default or a detector score.
Contents
- An automation wrapper can configure a real browser
- Startup has its own data flow
- A persistent context can use a temporary directory
- Response reuse has a separate storage boundary
- Configuration descriptions can disagree
- Different failures need different owners
- Practical conclusion
An automation wrapper can configure a real browser
Botright's public repository describes a Playwright-based Python interface. The source reviewed here is fixed at repository revision 2b275e27, rather than an unspecified future package. Its browser discovery first asks for a Chromium installation, then Chrome, then another eligible installed browser. If it cannot find a Chromium-based option, it raises an environment error. The implementation therefore depends on an executable outside the Python wrapper itself.
That dependency makes the phrase “only a wrapper” incomplete. A wrapper can pass startup arguments, set context options, intercept requests or select a different executable. Those actions can change browser behavior through interfaces that the browser implements. What they do not establish is that the Python package contains a replacement renderer or that every requested option is supported by every executable it might discover. A configuration request and the browser's implementation of that request are separate facts.
The context launcher makes the relationship concrete. It calls Playwright's launch_persistent_context with a chosen executable_path, a profile-directory path and assembled arguments. It then wraps the returned context with Botright's own object. The result has both browser-managed state and Python-managed behavior. Naming the result “browser” in an application does not remove that division of responsibility.
The Rebrowser library-patch comparison already distinguishes a library package from an executable in a controlled local comparison. Botright introduces a different decision: its initialization, proxy manager and optional cache add operations around the launched context. Reusing the general layer distinction is useful, but transferring another package's measured rendering results to Botright would not establish anything about this implementation.
Browser selection also affects reproducibility. The same application code can discover a different eligible executable on a workstation with different installations. A package version identifies the Python code; an executable path and browser version identify the process implementing web APIs. A report that records only “Botright” leaves out a material input. Conversely, a different result on two machines does not establish that the wrapper ignored an option, because the executable and its supported configuration may differ.
The source includes launch flags, but a flag's presence is evidence of an attempted launch configuration, not a measurement of a web-facing result. A browser can change supported flags between versions, interpret them differently or leave an option without effect. No execution or V8 recording was performed for this source reading. The justified claim is therefore about how the wrapper requests configuration, with browser behavior left to an appropriately scoped observation.
BotBrowser's browser overview places its supported surface controls in the browser engine and profile system. That is a different declared configuration location, not proof that every workflow needs it. A task that only needs page navigation and ordinary assertions can have different requirements from a privacy study of native rendering surfaces. The choice follows the required capability and evidence, rather than a ranking of product names.
Startup has its own data flow
A page's network panel begins too late to describe everything the Python client may do. In the pinned initializer, dependency setup occurs before the automation backend starts. A browser-discovery step and temporary-directory cleanup also appear during initialization. Constructing a client is therefore not merely assigning a Python variable. These are source-declared operations; they were not executed during the research.
For privacy assessment, startup effects need their own inventory. A dependency installer can have different recipients and permissions from an application page. Reading the call establishes that the initializer invokes setup; it does not establish exactly which files or network transfers a particular installed dependency version will perform. Those effects belong to that dependency and environment. They should not be replaced with an invented list of contacted hosts or dismissed because no page has navigated yet.
The proxy manager adds a more specific data flow. It constructs a direct HTTPX client. When a proxy is supplied, it also constructs a client configured to use that proxy. The egress-IP lookup uses the client passed to the check operation. The subsequent geographic lookup uses the direct client and places the returned IP address into the lookup request. These are two connection purposes with different route configuration.
When a proxy is configured, the geographic service can receive a query about the proxy's reported exit address over a connection originating from the client's direct route. That is a source-derived privacy exposure to assess, not a claim that a destination page receives both addresses. The lookup recipient and the destination application are different parties. The implementation's flow identifies what a particular request could carry; an actual deployment record would be needed to establish which fallback endpoint answered.
The two lookup loops have different stopping conditions. The IP loop advances after a caught exception, but stops when ip_request.json().get("ip") returns without throwing; it does not check that the returned IP value is usable before stopping. The geographic loop additionally requires a truthy country value before it stops. A candidate list therefore does not establish which providers were contacted in a deployment. Counting source URLs as confirmed transfers would turn static reading into an unsupported runtime claim.
The HTTPX constructors in this revision disable certificate verification, and one geographic fallback uses an HTTP URL. Those facts warrant a client-side transport review before handling sensitive operational data. Their scope is the Python lookup clients shown in the source. They do not establish the TLS configuration of Chromium's destination requests or every imported library. Treating all browser traffic as equivalent to a separately created HTTP client would repeat the same component-boundary mistake in another form.
The proxy configuration overview separates browser routing from related network decisions. Here that separation has an additional consequence: configuring the browser's proxy is not evidence that every preliminary Python request uses it. A privacy review should identify the calling process, request purpose and recipient before making a route claim. A successful exit-IP response answers a narrower question than “all data from this application follows one path.”
A persistent context can use a temporary directory
Playwright's persistent-context launch API accepts a user-data directory. In Botright's pinned context construction, that directory comes from TemporaryDirectory with a Botright prefix. The client keeps the temporary-directory object for cleanup. “Persistent context” names a browser launch interface and its storage location; it does not, in this implementation, promise a reusable profile across separate client lifetimes.
This distinction matters when a login disappears after a job. The code can use a directory-backed browser context during that job while arranging to remove its temporary data during client cleanup. A directory can persist browser state for the running context without being a long-term profile selected by the application. A team expecting durable account continuity needs a documented retention design, rather than inferring one from the word persistent in the launcher name.
The main client's cleanup closes collected browser objects, stops the automation backend and attempts to clean its temporary directories. Exceptions in several cleanup operations are caught. That supports a description of intended cleanup behavior, not a guarantee that every resource is removed under every interruption or operating-system condition. A process crash, permissions or a retained file handle can require separate observation. No disk-removal result was measured in this research.
Initialization also contains a scan for temporary directories with the package's prefix and a removal operation for matching directories. For a shared automation host, that is relevant to lifecycle ownership: a naming convention is being used to select cleanup candidates. Static reading does not prove interference between two jobs, but it does show why starting another client should not be assumed to have no relationship to older temporary data. A concurrency design needs to account for setup and cleanup, not only page creation.
The project documentation separately says its API is not thread-safe and suggests a client instance per thread. That advice concerns API use; it is not a proof that every process-wide resource or temporary-directory cleanup step is isolated by thread. A client-per-thread design and a resource-retention policy answer different questions. They should not be treated as interchangeable isolation guarantees.
The distinction also prevents a false comparison with a cloud browser. The Rebrowser proxy lifecycle article describes that service's declared reusable profiles and run boundaries. Botright's inspected path is a local temporary directory supplied to a persistent-context launcher. Similar vocabulary does not establish the same retention contract. Moving an application from one architecture to the other requires an explicit state-lifetime decision.
BotBrowser's Bot Script documentation describes another lifecycle boundary: a process-level automation bootstrap runs once and is not automatically inherited by newly created contexts. A context that needs its own bootstrap must receive one explicitly. That declaration should not be transferred to Botright's wrapper. It illustrates why automation setup, browser context creation and profile storage each need their own owner and lifetime.
Permissions are configuration, not consent history
The inspected new-browser operation requests notification and geolocation permissions on the returned context before adding it to the client's collection of resources to close. The context-launch dictionary also includes geolocation information derived from the proxy manager. These operations connect a preliminary lookup result to a browser configuration request. They do not establish that a real user physically occupied the queried location or personally accepted an application's permission prompt.
For authorized testing, an intentionally configured permission state can help exercise an application branch without a manual prompt. The privacy requirement is to keep that test state distinguishable from a person's consent record. A site receiving a location value cannot learn the application's internal test intent from that value alone. Likewise, a stored test permission is not a general authorization to reuse account data or query unrelated services.
The source establishes that permission calls are made; it does not show which origins a particular deployment visited, whether a permission-sensitive API succeeded there or what the destination stored. Those are separate observations. A review can record the requested permission categories and the source of the configured location without retaining a person's actual coordinates. The choice of test data should follow the owned application's requirement rather than the convenience of collecting more detailed location information.
This is another reason context boundaries need precise names. A context permission setting, a geographic lookup, an application consent decision and a provider's retained request record are four different facts. Keeping them distinct prevents a configured browser environment from being presented as a measurement of a user's identity or wishes.
Response reuse has a separate storage boundary
Botright exposes an optional response-cache feature. The main initializer creates one Python dictionary on the client. Each wrapped context receives that dictionary, and the response interceptor uses a request URL as its lookup key for selected resource types. A missing entry causes a fetch and storage of the response; an existing entry is used to fulfill the routed request. Other resource types continue through the route.
The selected resource types are document, stylesheet, image, media, font and manifest. That is a wrapper-managed response-reuse policy, separate from the browser's ordinary HTTP cache and cookie storage. The distinction matters because changing a browser profile directory does not explain the lifetime of the client's Python dictionary. An application that disables or clears browser cache has not, from that action alone, established what this independent store contains.
Consider an owned test application where the same document URL can return different authorized content for different sessions. The inspected cache key does not itself include the request's cookie, authorization state or context identifier. The static question is whether that response is appropriate to reuse for the next routed request under the feature's actual conditions. It would be premature to call this a demonstrated cross-account disclosure: no two-session experiment was run, and response handling depends on the surrounding automation and service behavior.
An application's state-isolation requirement must cover the wrapper's response store in addition to browser storage. If different contexts are passed the same cache object, a diagram containing only two separate browser boxes omits a shared dependency. Naming that dependency helps a team choose appropriate tests on its own application while keeping a hypothetical result distinct from an observed incident.
The cache also changes what a network observation means. A page may display a resource fulfilled from a stored response rather than a new destination request. Conversely, a request outside the selected resource types follows the continuation path. An operational report should distinguish a browser requesting a resource, the wrapper fulfilling a route and a server receiving a new HTTP exchange. These can have different counts and timestamps without any contradiction in the application's visible page.
Image blocking is another optional route-level behavior. This implementation intercepts common image extensions and checks resource types, aborting matching requests. That can alter page completeness, lazy-loading triggers or screenshot content in an authorized test. An absent image is not automatically a server refusal. Before attributing a changed page to a browser engine, the application needs to know whether its wrapper intentionally prevented the resource from loading.
Both cache reuse and image blocking default to disabled in the inspected initializer. The analysis concerns optional behavior when enabled, not a claim that every Botright run shares responses or blocks images. A deployment's effective options remain necessary evidence. Treating an available feature as always active would make the privacy assessment less accurate, even if the feature deserves careful review when selected.
Privacy choices for wrapper-managed data
Response bodies, proxy credentials and diagnostic artifacts have different retention purposes. An application can need a short-lived routing record without needing the full returned document. It can need to reproduce a missing image without preserving a logged-in page. The source's separate client-side stores and connections make that distinction visible: a browser profile is not the only place where operational data may exist.
A privacy review can therefore start with a data-owner table. Browser state belongs to the launched context and its directory; optional reusable responses belong to the client store; lookup requests have external recipients; destination accounts have their own server-side records. Each row needs a purpose, a retention boundary and an authorized operator. This is a design interpretation of the inspected ownership relationships, not a statement that the package implements a full retention policy for those rows.
Configuration descriptions can disagree
The options documentation and the initializer do not agree on every default. The table declares the user-action layer enabled by default, while the source signature sets it to False. It declares fingerprint masking disabled by default, while the asynchronous initializer sets that option to True. These are discrepancies within the same pinned repository, not a claim that any particular installed release used one value.
The source also distinguishes an initializer signature for editor assistance from the asynchronous method that actually assigns configuration. Looking at the first signature alone can therefore miss the relevant execution path. In this case the options considered agree between those two signatures, but the implementation still provides the stronger evidence for what the object stores. A documentation table explains intended use; the installed source and explicit arguments establish a more specific configuration question.
| Question | Pinned documentation | Pinned implementation | Operational consequence |
|---|---|---|---|
| User-action layer default | True | False | A report needs the actual effective option before interpreting an overlay's presence. |
| Fingerprint masking default | False | True | A missing explicit argument does not establish the setting described by the table. |
| New-browser result | Named as a browser type | Wrapped BrowserContext | Object naming is not evidence of a separate browser-process or storage boundary. |
| Proxy protocol scope | HTTP(S) support declared | Python proxy URL normalized to HTTP in the inspected path | SOCKS support must not be inferred from Playwright's broader API alone. |
The table is a reading aid for revision 2b275e27, not a replacement configuration recipe. A later package can change defaults, documentation or launch behavior. A bug report should distinguish an application argument, a documented default and a value assigned in the installed implementation. Collapsing those three into “the default” makes it harder to explain a difference after a dependency update.
Caller-supplied launch arguments are merged after the prepared context settings in the inspected dictionaries. That establishes a local precedence relationship for those dictionary keys. It does not prove that every possible extra argument is accepted by Playwright, or that all independently assembled command-line settings are reconciled with it. A browser launch still has multiple configuration inputs. A record of the requested settings is useful, but a disputed browser-facing behavior requires an observation at the claimed scope.
The optional modified automation backend has its own compatibility boundary. The wrapper explicitly raises unsupported-operation errors for certain context console and callback integration methods when that mode is active. Outside that condition it delegates to the original methods. This is a mode-dependent source declaration, not evidence that all ordinary Playwright integrations fail or that the browser engine lacks those capabilities. A callback-integration issue belongs to that interface before it belongs to a destination's policy.
Version identification also needs precision. The repository revision names the source that was read. A package installed from PyPI can have different code, dependency versions or bundled metadata. The repository's distribution and requirements declarations should be checked against the environment actually used before a source statement is assigned to it. No dependency installation was performed here; the current repository is not a tested lockfile.
Package requirements are not an environment record
The repository's distribution configuration declares a lower bound of playwright>=1.40.0, while its requirements file specifies playwright==1.42.0. Those declarations serve different installation inputs. A reader cannot infer the resolved automation-library version from the package name alone, or assume that installing the distribution reproduces a development environment assembled from the requirements file.
The same files give different forms of constraints for HTTPX and other dependencies. A lower-bound declaration allows a range that an exact requirement does not. That is evidence of installation flexibility, not proof that every permitted combination is compatible. A package manager's resolved environment, together with the executable actually selected at launch, supplies the missing operational context. The source reviewed here does not include a result showing every such combination was exercised.
This matters for the privacy interpretation as well as compatibility. A Python client's constructor options are interpreted by the installed HTTP library. A dependency setup call is interpreted by the installed setup dependency. Browser options are interpreted by the selected driver and executable. An audit can accurately identify these delegation points while leaving a version-specific effect unresolved. It should not silently fill that gap with behavior from a different release.
For an owned application, a dependency-change review can compare the resolved version inventory, explicit settings and the non-secret outcomes of its existing functional checks. That gives a concrete question for each changed component. It avoids treating a passing README example as a complete environment record and avoids collecting a new bundle of personal data simply to establish which package version was installed.
Different failures need different owners
An automation workflow can stop before browser launch, during launch, inside a wrapper method or after a destination responds. Each phase has different evidence. The proxy manager can raise an error when it cannot obtain an IP address or usable geographic information. Such an error does not, on its own, establish that an intended destination was contacted at all.
| Observation | First scope to inspect | What it does not establish |
|---|---|---|
| Initialization stops before a page exists | Dependency setup, browser discovery and preliminary lookup records | A destination rejection or a measured browser-surface difference |
| Browser launch does not return a context | Selected executable, effective launch settings and driver compatibility | That a page-level wrapper method caused the failure |
| A supported callback works in one mode only | The wrapper's conditional integration support | A universal lack of browser capability |
| A resource appears without a new server request | Optional route fulfillment and response-cache state | That the proxy carried a new transfer at display time |
| Images are absent in a captured page | Effective image-blocking option and routed request outcomes | That the application denied access |
| Login state changes between jobs | Context directory and cleanup lifecycle | That changing a network route erased server-side records |
This classification makes a report more useful without collecting secrets. A package revision, executable version, effective non-secret options and failure phase can be enough to distinguish initial owners. A live proxy URL, page token or full authenticated response should not be added merely because the report concerns browser automation. More captured data is not automatically more diagnostic evidence.
Source reading can establish that a method delegates, configures or conditionally rejects an operation. It cannot establish the current values returned by browser APIs in a live session. V8 logs would be appropriate for an attributed runtime API claim, provided the corresponding events were actually emitted and tied to their script source. None were collected here. A request log, successful navigation or a README benchmark is not a substitute for that observation.
The browser fingerprinting overview describes why storage, browser surfaces and network observations can contribute different information about an environment. Botright's architectural scope shows why changes to those dimensions need separate attribution. A Python-side option can request a browser setting, yet the resulting web-visible behavior still belongs to a specific executable, context and application exchange. A destination's authorization and response remain its own decisions.
Sources
- Botright pinned main initializer and browser discovery.
- Botright pinned context launcher, response handling and integration boundaries.
- Botright pinned proxy manager.
- Botright initialization and browser options documentation and project documentation.
- BotBrowser browser overview and Bot Script.
Practical conclusion
Botright's inspected scope spans Python initialization, browser launch configuration, wrapped context operations and optional response reuse. The next useful step for an authorized application is to record the package, executable, effective options and state owner relevant to its requirement. That distinguishes a missing capability from an assumption about where configuration or data lives, without turning product choice into a promise about a destination's response.
FAQ
Is Botright a separate browser engine?
The pinned implementation discovers an installed Chromium-based executable and launches it through Playwright. It also supplies configuration and wrapper behavior. That relationship does not make the Python package a renderer implementation, nor imply that its settings have no effect on the selected browser.
Does a successful proxy check cover every request?
No. With a supplied proxy, the IP query uses the proxy-configured Python client and geography uses the direct _httpx client. Without a proxy, both references point to the same client. Browser destination traffic remains another path. The recipient and route of each exchange require evidence for that exchange.
Does a temporary profile remove every retained copy?
No. Directory cleanup concerns that local browser-state location. The optional Python response store, diagnostic files and external service records have separate owners and lifetimes. Their deletion cannot be inferred from the temporary-directory launch API.
Do these source findings describe every Botright release?
No. They are bound to revision 2b275e27 and the cited public files. Installed package bytes, dependencies and effective arguments must match the scope before those statements are applied to an operational report. No live compatibility or detector result is asserted.
This article is part of the guide: What Is a Browser Fingerprint? Canvas Fingerprinting
Related Articles
Rebrowser Proxy: Routing, Profiles and Privacy
FingerprintBrowser Permission Fingerprinting: Privacy and Consistency
FingerprintAkamai Bot Manager: Sensor Data and Privacy
FingerprintRebrowser Patches: What Changes After a Proxy Works?
Getting StartedSelenium Scraping: Capabilities and Records
FingerprintWhat Private Browsing Does and Does Not Do
Run the same check in BotBrowser
Load a profile, keep the signals you just read about consistent inside the browser, and confirm the result on your own machine before a rollout.