A remotely downloaded, closed-source browser kernel executes locally
Source references: 4On first launch, the product obtains a closed-source Chromium kernel from the vendor CDN. Its actual behavior cannot be reviewed from the supplied source. It then processes pages, proxies, authenticated sessions, and local profiles. Pinning and hashes identify a file but do not reveal what the binary does.
If the vendor, CDN, release process, or kernel is compromised, the process could access account sessions, page data, and network traffic using the local account's permissions.
First launch downloads and caches a vendor-supplied, closed-source Chromium kernel, which then operates the browser and profiles containing login state. Pinning the SDK or verifying an artifact identifies the downloaded build but does not make the kernel's internal behavior reviewable. Users can ask for kernel signatures, hashes, update policy, and network/file permissions, and run it in isolation.
| SDK package | `anti-detect-browser` on npm, or `antibrow` on PyPI | Exact version in a committed lockfile; `npm ci` rather than `npm install` in CI. `npm view anti-detect-browser@2.8.0 dist.integrity` gives the published tarball hash to compare before adopting a version. No install scripts; dependencies are `ws`, `socks`, `yauzl`, `adm-zip`, `@modelcontextprotocol/sdk` || Browser kernel | a closed-source Chromium build the pinned package retrieves on first launch, cached in `~/.anti-detect-browser/` (~190 MB; ~320 MB for the macOS universal bundle) | Warm the cache during your image build rather than at run time - the Python CLI has an explicit `install` step for this, and on Node a single throwaway launch does it. Then mount `~/.anti-detect-browser/` as a volume so a running container needs nothing further. Installed kernels are never swapped underneath a live profile; updates happen only when explicitly requested |Show 3 other places
```bashpip install antibrowpython -m antibrow install # download the kernel (one-time; first launch does it too)python -m antibrow login # store the API key in ~/.antibrow/license.key```The SDKs (npm + PyPI) are **MIT**. The browser kernel is a **closed-source binary** downloaded from AntiBrow's CDN onto the end user's machine at runtime - usable for your own work including commercial work at any company size, but not redistributable, resellable or embeddable; exposing it to third-party customers needs a separate OEM/SaaS license. Listing these packages as a dependency is **not** redistribution. `BINARY-LICENSE.md` in `https://github.com/antibrow/antibrow` is the authoritative text.An API key is required at every launch - see [Supply chain](#supply-chain-what-runs-and-what-gets-downloaded) for how the license check behaves and why there is no offline mode. The token is cached, so a tight relaunch loop hits the network roughly once a day.Note what happens when. Executable code arrives **once, at install time**: the package from the registry, and the kernel it caches on first launch. Both can be warmed during an image build, after which a running container fetches no code at all. What crosses the network **at run time** is a signed licence token - a short string of data the kernel checks and caches, roughly one exchange a day, never code and never evaluated. Air-gapped environments are still unsupported, because that token exchange cannot be skipped; if a deployment cannot make any outbound call, this is the wrong tool.