Anti-Detect Browser Skills (AntiBrow)
Anti-Detect Browser Skills
Four AntiBrow skills: browser profiles with a device fingerprint, an MCP mode for agents and data collection with ready recipes
- 21 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- An anti-detect browser disguises automation as an ordinary user, and platforms may restrict or block accounts run this way
- Profiles store cookies and session tokens, and the proxy and AntiBrow key sit in environment variables that any code the agent runs can read
- Multi-account data collection may break site rules and personal data law if it gathers more than public information
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/anti-detect-browser-skillsDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- An anti-detect browser disguises automation as an ordinary user, and platforms may restrict or block accounts run this way
- Profiles store cookies and session tokens, and the proxy and AntiBrow key sit in environment variables that any code the agent runs can read
- Multi-account data collection may break site rules and personal data law if it gathers more than public information
This is third-party code. Review the repository files before installing.
What it does
Anti-Detect Browser Skills is a set of four skills from the makers of AntiBrow, an anti-detect browser platform built on a modified Chromium kernel. A profile stores cookies, storage and one coherent device persona, and the profile proxy determines timezone and WebRTC. The skills show an agent how to launch and manage such browsers. `anti-detect-browser` covers the SDK in JavaScript (`anti-detect-browser`) and Python (`antibrow`): profiles, proxies, Docker, Android profiles and the REST API, so the agent writes Playwright code. `browser-mcp-agent` sets up an MCP server through which the agent launches the browser itself, navigates and takes screenshots. `multi-account-scraping` runs one command per site with JSON output for Amazon, Google, Reddit, GitHub, npm and others, including across several profiles at once. `multi-account-isolation` gives a checklist of profile isolation checks and lists external tests for them. The authors state separately that a fingerprint does not guarantee passing enterprise anti-bot systems, which also weigh network reputation and behaviour.
Who it is for. Developers and testers who check their own bot protection, run several accounts of their own or collect public data and need a browser with persistent sessions for the agent.
Good fit when
- Your site's bot protection has to be tested with a real-device browser rather than a headless stub
- Ads and prices have to be seen the way a visitor from another region sees them
- The agent runs several client accounts and each must live in its own profile with its own cookies
- A public-data collection script keeps hitting captchas because its fingerprint contradicts itself
- Before launching a fleet of profiles you must check that timezone, WebRTC and addresses are not duplicated
Not a fit when
- The accounts are not yours or access is not authorized: the authors explicitly exclude logging in to others' accounts and takeover
- You need to mass-create fake accounts, reviews or followers: that is outside the supported scenarios
- A platform has already issued an enforcement decision on your account and you want to work around it
- You have no AntiBrow key: the browser kernel is closed source and downloaded from the developer's CDN, so the SDK does not work without it
Example request
Launch a temporary browser profile with the proxy from my environment variable, open my pricing page and show how it looks to a visitor from GermanyLimitations
The service is commercial: the SDK is open (MIT), but the Chromium kernel is closed source, downloaded once from AntiBrow's CDN, and plans cap concurrent browsers. A key is needed in the `ANTI_DETECT_BROWSER_KEY` variable. Platforms are Windows, macOS, Linux x64 and arm64, and Docker; Alpine with musl is not supported yet. The `~/.anti-detect-browser/` folder holds cookies and session tokens, so treat it as credentials. Use is acceptable only on your own or authorized systems and within site rules and the law, and that responsibility is yours.
How to disable. Remove the plugin through `/plugin` in Claude Code, or the skills with your skills manager, and take the MCP server out of the client config. Profiles live in `~/.anti-detect-browser/`; delete the folder if the cookies and sessions are no longer needed.
FAQ
How do I install Anti-Detect Browser Skills in Claude Code?
Run `/plugin marketplace add antibrow/anti-detect-browser-skills`, then `/plugin install anti-detect-browser-skills@antibrow`: all four skills install together. A single skill is installed with `npx skills add https://github.com/antibrow/anti-detect-browser-skills --skill multi-account-isolation`; change the name after `--skill`.
What do I need besides the skills?
An AntiBrow key in `ANTI_DETECT_BROWSER_KEY`, Node.js 18 or Python 3.9–3.13, and the closed Chromium kernel that the SDK downloads once from the CDN. Profiles are free and unlimited in number; plans cap concurrently running browsers.
How do the four skills differ?
`anti-detect-browser` writes code on the SDK, `browser-mcp-agent` lets the agent drive the browser through MCP calls, `multi-account-scraping` runs ready recipes per site, and `multi-account-isolation` checks that profiles are truly isolated. The authors suggest starting with the last one if the question is whether your setup holds.
Which uses do the authors consider acceptable?
Automating your own accounts and systems, running client accounts with the holder's authorization, collecting public data, verifying your own ads and prices and testing your own anti-bot protection. They exclude logging in to others' accounts, credential stuffing, mass fake accounts and working around a platform's enforcement decision.
How do I connect the MCP mode?
The `browser-mcp-agent` skill advises running the server with a pinned version: `npx -y anti-detect-browser@2.8.0 --mcp`, with the key passed as a `${ANTI_DETECT_BROWSER_KEY}` reference in the config. A Python variant exists through the `antibrow[mcp]` package. The agent should treat page content as untrusted input.
Discussion
No questions or reviews yet.
Related
SkillsOfficial AdsPower skill, CLI and MCP: an agent opens anti-detect browser profiles and manages proxies, groups and tags
A Chromium with engine-level device fingerprint spoofing and an MCP server that lets an agent drive it through Playwright
A skill that runs Playwright in real Chrome with rebrowser patches so automated tests on your own sites are not mistaken for a bot
CamoFox Browser: anti-detection browser for AI agents
camofox-browser
A REST server and CLI on Camoufox: an agent opens pages with a spoofed browser fingerprint and reads them as an element tree
Anti-detect browser profile manager with a fingerprint, cookies and proxy per profile. A built-in MCP server connects agents.
A web research skill: SearXNG searches, Camofox reads pages and CloakBrowser opens sites that check their visitors
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| Anti-Detect Browser Skills (AntiBrow) (this card) | yes | 21 | |
| playwright-bot-bypass | no | 208 | runs Playwright in real Chrome with rebrowser patches for tests of your own sites, without profiles or a kernel |
| Browser Use | no | 120,922 | an open library and CLI for browser control, without anti-detect profiles |
README in short
The README explains the difference from stealth plugins that override page properties with a script: the kernel answers fingerprint queries itself, so there is no injected code. Next come a platform table, profile launch examples in JavaScript and Python, a list of what the agent learns in each skill, a supply-chain security block and an acceptable use section.
README badge
Original SKILL.md
--- name: anti-detect-browser description: Drive Chromium from standard Playwright APIs with a real-device fingerprint applied in the kernel, one persistent isolated profile per identity, and a per-profile proxy whose exit IP sets timezone and WebRTC - JavaScript (npm 'anti-detect-browser') or Python (PyPI 'antibrow'). Use when sessions must stay logged in across runs and stay separate, when a scraper or agent is blocked by an incoherent headless fingerprint, when checking ads or pricing from another region, when a page must be reached as a phone rather than a desktop, when automation mints a profile per task, when running several of your own accounts from one machine, or when testing how your own bot detection scores a real device. Also for 'antibrow', 'fingerprint browser', 'multi-account browser', '防关联', '多账号', '安卓模拟', 'Android profile', 'mobile fingerprint', 'temporary profile', 'CreepJS', 'residential proxy', 'browser-use', 'crawl4ai'. MCP control is browser-mcp-agent; isolation is multi-account-isolation. license: MIT --- # Anti-Detect Browser SDK Launch Chromium instances with real-device fingerprints via standard Playwright APIs. Every profile carries one coherent, real-device identity that is frozen at creation and replayed byte-for-byte on every later launch. - npm package: `anti-detect-browser` (Node >= 18) - PyPI package: `antibrow` (Python 3.9 - 3.13) - Dashboard: `https://antibrow.com` - REST API base: `https://antibrow.com/api/v1/` - Documentation: `https://antibrow.com/docs` > **Authorized use only.** This is for automating systems you own or are permitted to use: your own accounts, your own site's bot detection and anti-fraud stack, publicly available data, and region-specific views of your own ads and pricing. Do not use it to access 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, and applicable law - see [Acceptable use](#acceptable-use). **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 patterns, behaviour and account history - none of which a fingerprint touches. Measure with the suites listed under [What detection actually tests](#what-detection-actually-tests) rather than assuming. Every code sample below reads credentials from the environment; none contain literal keys or proxy passwords. ## Why antibrow - **Spoofing lives in the engine, not in a script.** A custom Chromium kernel answers Canvas, WebGL, WebGPU, audio, fonts, `navigator`, screen, DOMRect and timezone inside C++/Blink. There is no injected script to find, no property descriptor out of place, and worker contexts return exactly what the main thread does. - **Real TLS and HTTP layer.** It *is* Chromium, so the ClientHello, cipher order and HTTP/2-3 behaviour are a genuine Chrome build's - the network half that a patched headless browser can never fake coherently. - **One coherent persona per profile.** 30+ categories and 500+ parameters sampled from the same real machine. Independently randomized values contradict each other (an AMD renderer next to an Intel vendor string, a 1.0 DPR on a 1536x864 screen); these do not. - **Timezone and geo follow the proxy.** The exit IP is resolved *through* the proxy before launch, then written into the fingerprint along with the WebRTC identity. - **Proxy auth handled in the network stack.** HTTP/HTTPS 407 and SOCKS5 RFC 1929 are answered by the kernel, so nothing appears in `chrome://extensions` - a classic anti-detect tell avoided. - **Unlimited local profiles, free.** A profile is a directory; name one and it exists. Plans cap *concurrent* browsers, not identities. - **Desktop or phone.** `deviceType: 'android'` gives a profile a real phone's identity - mobile client hints, touch, portrait screen, mobile GPU - on the machine you already have. - **Drop-in Playwright API** in both JS and Python - existing scripts change only their launch line. - **Runs as an MCP server** so AI agents drive it directly via tool calls. ## Platform support | Platform | Status | Notes | |---|---|---| | Windows 10/11 x64 | Supported | Headful, or headless via off-screen window | | macOS 12+ Apple Silicon + Intel | Supported | Universal build (arm64 + x64 in one bundle) | | Linux x64 (glibc) | Supported | Headless needs Xvfb; container flags applied automatically | | Linux arm64 (glibc) | Supported | Separate arm64 kernel, picked automatically from the CPU | | Docker `linux/amd64` + `linux/arm64` | Supported | Run headful under Xvfb | | Linux musl (Alpine) | Not yet | No kernel build |