⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
browser-mcp-agent
Give an AI agent its own real browser over MCP tool calls - launch, navigate, click, fill, screenshot, extract text, run JS - with a kernel-level real-device fingerprint and a persistent profile, so the session stays logged in between runs and pages see one coherent device instead of a headless build. No Playwright or SDK code to write. Use when an agent should operate a site itself, when a computer-use / browser-use setup needs a captured real fingerprint rather than a synthetic one, when agent sessions keep losing their login, or when comparing hosted agent-browser services. Also for 'MCP browser', 'browser MCP server', 'let my agent browse the web', 'agent browser control', 'browser-use MCP', 'computer use browser', 'Browserbase alternative', 'Steel browser alternative', 'headless browser detected'. Node (npx) or Python; Windows x64, macOS Intel + Apple Silicon, Linux x64 / arm64. SDK and REST reference is anti-detect-browser; account isolation is multi-account-isolation.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
Anti-Detect Browser - Claude Code Skills
Agent Skills for driving a browser that presents one coherent real device instead of a headless build: persistent isolated profiles, kernel-level fingerprints, and a per-profile proxy whose exit IP sets timezone and WebRTC. They teach an agent how to launch and manage AntiBrow browsers, both by writing code against the SDK (JavaScript or Python) and by letting the agent drive the browser directly via MCP.
Typical uses: QA and bot-detection testing against your own site, checking your own ads and pricing from another region, scraping public data, giving an agent a browser that stays logged in, and keeping identities you own or are authorized to operate in genuinely separate profiles. See Acceptable use.
Skills in this repo
- multi-account-isolation - verifying that profiles are actually isolated rather than assuming it: ten concrete checks (timezone vs exit IP, WebRTC, canvas stability across relaunches, duplicate personas or addresses across a fleet), which detection suites to run, what the runtime does with your credentials, and which layers browser isolation cannot cover at all. Start here if the question is "is my setup actually holding?".
- anti-detect-browser - SDK (npm
anti-detect-browser+ PyPIantibrow), profiles, fingerprints, proxies, kernel updates, Docker, and the REST API. Use this to write custom scraping, multi-account, or automation scripts. - browser-mcp-agent - MCP server mode. Use this to let an AI agent (Claude, GPT, etc.) launch and control the browser itself via tool calls, with no code to write.
- multi-account-scraping - running the same scrape or task across many accounts at once, each in its own profile with its own fingerprint, cookies and exit IP, and reading data from sites that need a session or that answer a plain HTTP scraper with a captcha. One command per site returns JSON, so there are no selectors to write or repair: Amazon, Walmart, Google, DuckDuckGo, Reddit, X, Medium, Yelp, Indeed, Hacker News, GitHub, PyPI, npm. Also covers writing a new adapter, and the domain allowlist plus SHA-256 pinning that make a third-party one safe in a profile that holds live logins. Use this when the goal is data from a site, not a browser.
Install
As a Claude Code plugin (recommended)
Installs all four skills together and keeps them updatable via /plugin update:
/plugin marketplace add antibrow/anti-detect-browser-skills
/plugin install anti-detect-browser-skills@antibrow
As individual skills
Works with Claude Code and any other agent the skills CLI supports:
# isolation self-check
npx skills add https://github.com/antibrow/anti-detect-browser-skills --skill multi-account-isolation
# SDK / scripting skill
npx skills add https://github.com/antibrow/anti-detect-browser-skills --skill anti-detect-browser
# MCP agent-driven skill
npx skills add https://github.com/antibrow/anti-detect-browser-skills --skill browser-mcp-agent
# multi-account scraping / per-site JSON commands
npx skills add https://github.com/antibrow/anti-detect-browser-skills --skill multi-account-scraping
# all of them
npx skills add https://github.com/antibrow/anti-detect-browser-skills --all
Or add the repo URL in Claude Code settings under Skills and pick which skill(s) to install.
What makes this different from a stealth plugin
Most stealth tooling patches JavaScript from the outside: override a getter, shim navigator, monkey-patch toString. Anti-bot vendors have been fingerprinting those patches for years - the patch is the tell.
AntiBrow ships a modified Chromium kernel. Canvas, WebGL, WebGPU, audio, fonts, navigator, screen, DOMRect and timezone are answered inside C++/Blink, so:
- there is no injected script to find and no property descriptor out of place;
- Web Workers return exactly what the main thread does (detectors re-read identity inside workers precisely because partial overrides only patch the main thread);
- canvas and WebGL reads are deterministic per profile - a browser that returns a new hash on every read is trivially flagged, and so is one whose OffscreenCanvas disagrees with its 2D canvas;
- WebGL, WebGL2 and WebGPU name one GPU -
adapter.info.vendormatches the unmasked renderer family; - the TLS ClientHello and HTTP/2-3 behaviour are a genuine Chrome build's, because it is one. Nothing running in JavaScript can reach that layer.
Each profile gets one coherent persona sampled from one real machine - 30+ categories, 500+ parameters - frozen at creation and replayed on every later launch. Independently randomized values contradict each other (an AMD renderer beside an Intel vendor string, a 1.0 DPR on a 1536x864 screen); a real device's don't.
Timezone, locale and WebRTC identity follow the proxy: the exit IP is resolved through the proxy before launch. Proxy credentials are answered inside the network stack (HTTP 407, SOCKS5 RFC 1929), so nothing shows up in chrome://extensions.
Want to check any of that yourself: CreepJS, whoer.net, browserleaks.com/canvas, pixelscan.net, or npx liarjs (liarjs.dev) for ~40 open-source cross-layer consistency rules you can run in CI.
Platforms
| Platform | Status |
|---|---|
| Windows 10/11 x64 | Supported |
| macOS 12+ (Apple Silicon + Intel) | Supported - universal build |
| Linux x64 (glibc) | Supported |
| Linux arm64 (glibc) | Supported - separate arm64 kernel, auto-selected from the CPU |
Docker linux/amd64 + linux/arm64 | Supported - headful under Xvfb |
| Linux musl (Alpine) | Not yet |
Two SDKs, one profile format
npm install [email protected] playwright-core # Node >= 18; pin the version
pip install antibrow==0.9.0 # Python 3.9 - 3.13
const ab = new AntiDetectBrowser({ key: process.env.ANTI_DETECT_BROWSER_KEY })
const { page, browser } = await ab.launch({ profile: 'shopper-01' })
from antibrow import launch
browser = launch(profile="shopper-01") # same profile, same fingerprint
page = browser.new_page()
Both share ~/.anti-detect-browser/, so a profile created from Node is launchable from Python (and from the desktop app) with the identical identity. playwright install is never needed - AntiBrow drives its own kernel.
What Claude learns
From multi-account-isolation:
- The configuration invariant - one identity, one profile, one persona, one egress, one timezone; what a shared cell breaks
- Eleven concrete checks - timezone vs exit IP, WebRTC candidates, canvas stability across relaunches, worker vs main thread, one GPU across three interfaces, no duplicate personas or addresses across the fleet
- Which suites to run - CreepJS, whoer, browserleaks WebRTC, pixelscan, and
npx liarjsfor the ~40 rules you can run unattended in CI - Reading a failure - the cheap causes (reused profile name, duplicate address, clock/address disagreement, a persona that regenerated) before suspecting the fingerprint
- Runtime transparency - where cookies, personas, proxy credentials and the API key actually go, and how to verify it yourself
- What isolation cannot cover - everything outside the browser, stated plainly
From anti-detect-browser:
- JS/TS SDK -
AntiDetectBrowser,launch()options,applyFingerprint()for existing Playwright setups, kernel update APIs, and kernels named by Chrome major (150,151) since 2.8.0 - Python SDK -
launch()/launch_async()/launch_persistent_context()/prepare_launch(), theAntibrowhandle, error types,python -m antibrowCLI, env vars, Docker - Framework integrations - hand the CDP endpoint to browser-u
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
browser-mcp-agent/SKILL.md7.8 KBupstream ↗
--- name: browser-mcp-agent description: Give an AI agent its own real browser over MCP tool calls - launch, navigate, click, fill, screenshot, extract text, run JS - with a kernel-level real-device fingerprint and a persistent profile, so the session stays logged in between runs and pages see one coherent device instead of a headless build. No Playwright or SDK code to write. Use when an agent should operate a site itself, when a computer-use / browser-use setup needs a captured real fingerprint rather than a synthetic one, when agent sessions keep losing their login, or when comparing hosted agent-browser services. Also for 'MCP browser', 'browser MCP server', 'let my agent browse the web', 'agent browser control', 'browser-use MCP', 'computer use browser', 'Browserbase alternative', 'Steel browser alternative', 'headless browser detected'. Node (npx) or Python; Windows x64, macOS Intel + Apple Silicon, Linux x64 / arm64. SDK and REST reference is anti-detect-browser; account isolation is multi-account-isolation. license: MIT --- # Browser MCP Agent Run antibrow as an MCP server so an AI agent can launch and control a real, fingerprinted browser directly through tool calls - no Playwright code, no custom automation script. The agent navigates, clicks, fills forms, and reads pages itself. - npm package: `anti-detect-browser` (Node >= 18) - ships the MCP server built in - PyPI package: `antibrow` (Python 3.9 - 3.13) - `pip install "antibrow[mcp]"` for a stdio MCP server example - Dashboard: `https://antibrow.com` - Full SDK / REST API reference: see the `anti-detect-browser` skill > **Authorized use only.** Point this at sites and accounts you own or are permitted to operate: your own apps, your own accounts, publicly available pages, your own bot detection under test. Do not use it to reach systems without authorization, to log into accounts that are not yours, to create fake accounts or engagement, or to work around a platform's enforcement decision. Respect each site's terms, `robots.txt` and rate limits - see [Acceptable use](#acceptable-use). **This gives an agent real capability, so scope it deliberately.** The server hands the model a browser that persists logins, executes JavaScript in the page, and can stream its screen to a shareable URL. That is the point of the tool and also its blast radius: an agent that goes wrong here goes wrong inside a logged-in session. Run untrusted browsing in a throwaway profile, keep tools you do not need out of the toolset, and read [Everything the browser returns is untrusted input](#everything-the-browser-returns-is-untrusted-input) before pointing it at the open web. **What this does not claim.** A coherent real-device fingerprint removes the contradictions a synthetic browser leaves behind. It is not a guaranteed pass against enterprise bot managers, which also score network reputation, request cadence and behaviour. ## Why this over a generic browser MCP Generic "agent controls a browser" servers hand the agent a stock or patched headless Chromium. Every page the agent visits sees the tells: a `navigator` override that is not `[native code]`, a canvas hash that changes on every read, a worker thread disagreeing with the main thread, a headless build's own fingerprint. antibrow's spoofing happens **inside the Chromium kernel**, so the agent gets a browser whose Canvas, WebGL, WebGPU, audio, fonts, screen and timezone all agree - and whose TLS ClientHello and HTTP/2-3 behaviour are a genuine Chrome build's, because it is one. Sessions also **persist**: the agent logs in once under a profile name and stays logged in. ## Platform support Windows 10/11 x64 · macOS 12+ (universal build, Apple Silicon + Intel) · Linux x64 and **arm64** (glibc) · Docker `linux/amd64` and `linux/arm64`. The correct kernel build is picked from the CPU automatically. Alpine/musl is not supported yet. ## When to use - **Agent-driven browsing** - the agent itself should navigate a site, log in, click through a flow, or extract content, without anyone writing automation code first - **Computer-use / browser-use style setups** - the same idea as generic "agent controls a browser" tools, but backed by a real captured device fingerprint rather than a synthetic headless browser - **Ad-hoc one-off tasks** - "go check my dashboard and tell me X" requests where writing a script would be overkill - **Debugging agent browser actions** - watch what the agent is doing in real time via Live View while it works ## Setup Install the package once, from the npm registry, at a version you have reviewed: ```bash npm install -g [email protected] npm view [email protected] dist.integrity # compare before adopting a new version ``` Then point the MCP config at the installed binary - no package resolution, no download, at server start: ```json { "mcpServers": { "anti-detect-browser": { "command": "anti-detect-browser", "args": ["--mcp"], "env": { "ANTI_DETECT_BROWSER_KEY": "${ANTI_DETECT_BROWSER_KEY}" } } } } ``` Two things there are deliberate: - **Nothing is fetched when the server starts.** A config built on `npx` re-resolves the package from the registry on every launch, so the code that runs is whatever was published most recently. Installing once pins it to a version you can review, diff and roll back. If your setup must use `npx`, at least pin the version - `["-y", "[email protected]", "--mcp"]` - and never leave it resolving `latest`. - **The key is a variable reference, not a value.** `${VAR}` is expanded from the environment when the config is read, so no secret is written into `.mcp.json` - a file people commit. Use `${ANTI_DETECT_BROWSER_KEY:-}` if you want a missing key to fail loudly rather than expand to the literal string. Get your API key at `https://antibrow.com` - the free key gives 1 concurrent browser and unlimited local profiles. The browser kernel is a separate ~190 MB binary (~320 MB for the macOS universal bundle) that the package fetches on first launch and caches under `~/.anti-detect-browser/`; see [Supply chain](#supply-chain) below before running this anywhere that matters. ### Python For a Python agent stack, `pip install "antibrow[mcp]==0.9.0"` from PyPI. The SDK repository also carries a worked stdio-server example (`python/examples/09_mcp_server.py`) - read it and adapt it into your own project rather than wiring the config to a path inside a cloned repo, so the file the server executes is one you own and review: ```json { "mcpServers": { "antibrow": { "command": "python", "args": ["/abs/path/to/your/own/mcp_server.py"], "env": { "ANTIBROW_API_KEY": "${ANTIBROW_API_KEY}" } } } } ``` ## Supply chain Three things reach the machine. Know what each one is before running this outside a sandbox. | Artifact | Source | How to pin and verify | |---|---|---| | `anti-detect-browser` | npm registry | Install an exact version; `npm view [email protected] dist.integrity` gives the published tarball hash. No install scripts; dependencies are `ws`, `socks`, `yauzl`, `adm-zip`, `@modelcontextprotocol/sdk` | | `antibrow` (Python path) | PyPI | `pip install "antibrow[mcp]==0.9.0"`, exact version, in a lockfile | | Browser kernel | AntiBrow's CDN, fetched by the package on first launch | Closed-source Chromium build, cached in `~/.anti-detect-browser/`. Prefetch it during a build and mount the cache, so a running agent never triggers a download | The kernel being a closed binary from a small vendor is a real supply-chain consideration, not a formality - it is the tradeoff for the spoofing living in C++ rather than in an injectable script. Treat it the way you would any vendor binary: install it deliberately, pin it, keep it in an image you built, and if a deployment cannot accept a closed binary that phones home for license verification, this is the wrong tool - there is no offline mode. It exposes `launch_browser`, `naviREADME.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/antibrow-anti-detect-browser-skills-browser-mcp-agent.md