EyeBrowse
About
Stealthy, LLM-drivable browser engine — a Python library + 85-tool MCP server on stealth Chromium with full Chrome DevTools Protocol.
Details
- Author
- evil-bane
- Categories
- Web Scraping, Automation, Other
Jump to
Setup
Install EyeBrowse in your MCP client (Claude Desktop, Cursor, Windsurf, and others).
Repository: https://github.com/evil-bane/eyebrowse
Follow the installation instructions in the repository README, then restart your MCP client.
A stealthy, LLM-drivable browser engine — one codebase, two faces.
APython libraryandanMCP serverfor driving a real, hard-to-detect browser, so legitimate automation isn't false-flagged or IP-banned by Cloudflare, DataDome, Akamai, or PerimeterX. Built onCloakBrowser— a stealthChromium(Chrome/146) that's a Playwright drop-in — so EyeBrowse gets the fullChrome DevTools Protocol: trusted cursorless clicks, deep network inspection, MHTML, PDF, and native video.
▶ Full-quality MP4:docs/demo.mp4— an AI agent drives EyeBrowse over MCP: clears a Cloudflare check, then reads real docs (asyncio · httpx · MDN).
- 🥷Stealth by default— engine-level fingerprint spoofing (geoip+humanizeon out of the box, novel fingerprint per launch);navigator.webdrivermasked; viewport auto-sized to the spoofed screen. Nopuppeteer-extraband-aids — the anti-detection iscompiled into the browser.
- 🤖Built for LLMs— pages are read as anARIA tree with[ref=…]handles; the model acts by ref (click/type/hover), not by brittle CSS or raw pixels. Cross-origin iframes, shadow DOM, popups — handled.
- ⚡Chrome DevTools Protocol—trusted, cursorless clicksby node ref (Input.dispatchMouseEvent), rawNetwork/Performance/Emulationaccess,MHTMLsnapshots,PDFexport, andnative video— all reachable as tools.
- 🧰LibraryandMCP from one codebase— a clean Python API (EyeBrowse+Session), mirrored 1:1 by a thinMCP server(85browser_tools) for Claude Code and any MCP client.
- 🪟Never boxed in— the curated high-level API doesn't hide Playwright: reachsession.page/.context/.browserfor anything it doesn't wrap.
- 🔋Batteries included— multi-session, proxy + identity rotation, API-mode captcha solvers, native video, fullHARcapture, and clean-markdown extraction.
Scope.EyeBrowse is a low-level browserengine— it holdsno workflow logic. Consumers decidewhatto do; the engine provideswhat's possible.
Quickstart·Install·Features·Compare·Library·MCP·Proxy & identity·Extraction·Recording·How it works·Caveats·Tools·License
pip install eyebrowse # The stealth-Chromium binary downloads automatically on first launch — nothing else to run.
import asyncio from eyebrowse import EyeBrowse async def main(): eb = EyeBrowse() # stealth defaults: geoip · humanize async with eb.session() as s: await s.navigate("https://example.com") print(await s.snapshot()) # ARIA tree with [ref=...] handles await s.click("e6") # act on a ref from the snapshot await eb.aclose() asyncio.run(main())
…or wire it intoClaude Code(or any MCP client) — seeUse over MCP.
pip install eyebrowse # or: uv pip install eyebrowse # CloakBrowser fetches its Chromium binary lazily on first launch — nothing to run. pip install "eyebrowse[extract]" # optional: + Crawl4AI markdown extraction (heavier)
git clone https://github.com/Evil-Bane/eyebrowse && cd eyebrowse uv sync # core engine (add --extra extract for Crawl4AI) cp .env.example .env # only if you use a proxy / captcha keys
Python 3.12 (pinned<3.13). Engine:cloakbrowser>=0.3(stealth Chromium, Chrome/146), onplaywright 1.60andmcp 1.27.
Full per-tool reference:docs/TOOLS.md(85 tools across 18 groups).
Fair-use note: each project targets a different niche — this compares them on the axes EyeBrowse optimizes for (stealth + LLM-drivable + one library/MCP codebase), not as an overall ranking.
import asyncio from eyebrowse import EyeBrowse async def main(): eb = EyeBrowse() # stealth defaults try: async with eb.session() as s: # a stealth session (auto-closed) await s.navigate("https://example.com") print(await s.snapshot()) # ARIA tree with [ref=...] handles await s.click("e6") # act on a ref await s.type("e8", "hello", submit=True) png = await s.screenshot(full_page=True) title = await s.page.title() # full Playwright power when you need it finally: await eb.aclose() asyncio.run(main())
Run the included proof:uv run python examples/direct_usage.py.
EyeBrowse ships an MCP server (eyebrowse-mcp, FastMCP over stdio). Add it to any MCP client.
claude mcp add eyebrowse -- eyebrowse-mcp
{ "mcpServers": { "eyebrowse": { "command": "eyebrowse-mcp" } } }
Then drive the loop:browser_navigate(url)→ read the snapshot → act by ref (browser_click/browser_type/ …). A default session is auto-created, so most tools just work. Full list:docs/TOOLS.md.
Runsproxyless by default(geoipstill aligns locale/timezone to your real IP). Add a proxy only when you want one:
await eb.new_session(proxy="http://user:pass@residential.example:8080") await eb.rotate_identity(proxy="socks5://host:1080") # fresh fingerprint + paired IP await eb.new_session(no_proxy=True) # force proxyless
Set a default once viaEYEBROWSE_PROXY_in.env,eb.set_static_proxy(...), or a customProxyProviderfor rotation. Over MCP:browser_new_session(proxy_url=…)/browser_new_identity(proxy_url=…)/browser_set_proxy(…).
reCAPTCHA v3 / reputation gatesare score-based and key off IP + session reputation — a fresh browser on a flagged IP fails regardless of stealth. Pair EyeBrowse with a clean residential proxy.
eb.extract()(orbrowser_extract) hands the rendered HTML to Crawl4AI'sraw:feed and returns clean, prunedmarkdown—no LLM is called and no LLM keys are ever read; the consuming agent does any structuring.
md = await eb.extract() # markdown string res = await eb.extract(output_path="data/page.md") # → {"path": ..., "chars": ...}
Native video— Playwright records the whole session to a.webm, written on close. The path is known up-front; the file finalizes when the session closes:
s = await eb.new_session(record_video=True) # ... drive the browser ... print(await s.video_path()) # path is known up-front; file finalizes on close await eb.close_session(s.id)
Over MCP:browser_new_session(record_video=True)→browser_video_path. Want a GIF for a README? Convert the.webmwith ffmpeg (ffmpeg -i demo.webm demo.gif). The demo at the top was captured this way — seeexamples/make_demo.py.
CONSUMERS ENGINE (library: eyebrowse/) Claude Code ──MCP──▶ mcp/ ──▶ EyeBrowse façade (public API) your code ─ import ──────────▶ ├─ BrowserEngine (CloakBrowser / stealth Chromium) any MCP client ├─ proxy / identity rotation (pluggable) ├─ captcha solvers (pluggable, API-mode) └─ Crawl4AI (raw: feed) → clean markdown
The façade (EyeBrowse+Session) is the product; the MCP adapter is a thin 1:1 wrapper over it. The high-level API is curated and LLM-friendly —nota reimplementation of all of Playwright — and the rawpage/context/browserobjects are always one attribute away. The launcher is the only engine-specific layer; everything else is plain Playwright.
- evaluateruns in the page's main world (page globals reachable). To override a page's widget globals and fire a site callback (e.g. for captcha), EyeBrowse injects a<script>so the code runs in the page world — seecaptcha/inject.py.
- HAR export closes the session— Playwright only flushes the HAR buffer when the context closes. Use the checkpoint pattern:browser_storage_state→browser_har_export→browser_new_session(storage_state=...). For the initiator-rich Chrome HAR (JS call stacks), reach theNetwork.*domain viabrowser_cdp_send.
- Native video is.webm— convert to GIF/MP4 with ffmpeg if you need another format.
eyebrowse/ api.py EyeBrowse façade — the single public entry point config.py settings / secrets (pydantic-settings) snapshot.py aria_snapshot(mode="ai") + aria-ref= resolution proxy.py ProxyConfig + pluggable ProxyProvider identity.py Identity + random_identity() (isolated profile dir) extract.py Crawl4AI raw: feed → markdown (lazy, optional dep) engine/ engine.py (CloakBrowser launch) + session.py (verbs + registry) captcha/ solver ABC + 4 providers + DOM detect/inject mcp/ FastMCP server + state + tools/ (18 groups · 85 tools) examples/direct_usage.py library proof (no MCP) examples/make_demo.py the native-video demo above docs/TOOLS.md full tool reference
Build notes, version-pin rationale, and verified engine behavior live inCLAUDE.md.
EyeBrowse drives a real browser with anti-detection features. Use it only against sites you own or are explicitly authorized to automate, and within their terms and applicable law.
Found EyeBrowse useful?⭐ Star the repo — it genuinely helps.
Built with Python · Playwright · CloakBrowser · FastMCP · the Model Context Protocol
MCP server for browser automation via Vercel agent-browser CLI
Convert any URL to LLM-ready Markdown via real Chrome browsers. 3 tools: scrape, crawl, search. Free via MCP, pay-per-use via x402.
An MCP server that allows AI agents to control a web browser using the browser-use library.
Exposes Chrome browser functionality to AI assistants for automation, content analysis, and semantic search via a Chrome extension.
Control a Chrome browser through the Chrome DevTools Protocol (CDP) from MCP clients for browsing, inspection, and automation workflows.
Multi-session browser MCP for AI agents — stealth mode, session pooling, humanization, 10x fewer tokens than Playwright
A Go-based MCP server for interacting with the Lightpanda Browser using the Chrome DevTools Protocol (CDP).
A browser automation agent using the Model Context Protocol (MCP) to enable browser interactions.
A browser automation service for capturing console output, useful for tasks like public sentiment analysis.
Control the Chrome browser for web automation using an AI model. Requires the MCP Chrome extension.
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
