Skip to main content
Glama
AginxBrowser

AginxBrowser

AginxBrowser

AI 에이전트를 위한 브라우저. 라이브 웹을 보고, 상호작용하세요.

skills.sh License MCP Hosted

English | 中文文档

첫 줄의 코드부터 에이전트를 위해 만들어진 브라우저 — 자동화에 억지로 붙인 인간용 브라우저가 아닙니다. 세상을 보고, 읽고, 검색하고, 행동하세요: 내장 V8을 갖춘 단일 Rust 바이너리, Chromium 불필요.

인간에게는 Chrome이 있습니다. 에이전트에게는 AginxBrowser가 있습니다.

단일 바이너리, 제로 의존성, 즉시 서비스. HTTP API + 네이티브 MCP — 에이전트는 연결만 하면 바로 사용할 수 있습니다.

에이전트가 자체 브라우저를 필요한 이유

기존의 "브라우저 자동화"는 인간을 위해 또는 일회성 스크래핑을 위해 만들어졌습니다 — 에이전트를 위한 것이 아닙니다:

AginxBrowser

Puppeteer/Playwright

Firecrawl

Browser-use

설계 대상

에이전트 우선

인간 디버깅

스크래핑 서비스

LLM 래퍼

의존성

단일 바이너리, Chromium 불필요

Chromium ~500MB

Docker ~1GB

Chromium

보기 (스크린샷)

✅ 내장 diting 렌더링 엔진

Chromium 필요

❌

Chromium 필요

읽기

markdown + js_extract

직접 구현

markdown

직접 구현

찾기 (검색)

✅ 5엔진 메타 검색

❌

❌

❌

행동

인덱싱된 세션 상호작용

DevTools API

❌

LLM 기반

프로토콜

HTTP + 네이티브 MCP

Node API

HTTP

Python

TLS 핑거프린트

✅ Chrome/Firefox/Safari

플러그인 필요

❌

❌

CAPTCHA 해결

✅ 자동

직접 구현

❌

❌

대화형 세션

✅ 영구

✅

❌

✅

에이전트는 브라우저에서 다섯 가지가 필요합니다: 보고, 읽고, 찾고, 행동하고, 배포하는 것. 하나의 바이너리가 이를 모두 충족합니다 — systemd 친화적, Claude/Cursor를 위한 MCP 네이티브, 제로 의존성.

핵심 장점: Chromium 불필요. AginxBrowser는 전체 브라우저 엔진을 내장합니다 (V8 + Rust HTTP 스택 + 자체 diting CSS/레이아웃/페인트 렌더링 엔진, 참조 구현으로 Blitz/Stylo/Taffy 계열). Puppeteer도, Chrome도, Docker도 필요 없습니다. systemd 아래의 단일 Rust 바이너리가 곧 에이전트 브라우징 인프라입니다.

Related MCP server: Web Bridge

상태 비저장 렌더러가 할 수 없는 세 가지

대부분의 새로운 "에이전트 브라우저"는 상태 비저장, 핑거프린트 없는 일회성 렌더러입니다 — 공개 페이지에는 괜찮지만 Cloudflare나 로그인 흐름 앞에서는 시작부터 실패합니다. AginxBrowser는 반대 방향으로 갑니다:

  • 🔐 실제 TLS 핑거프린트 — 스텔스 모드는 BoringSSL을 통해 Chrome145 / Firefox133 / Safari / Edge TLS 핸드셰이크 전체를 복제합니다 (단순한 UA 문자열이 아님), 요청별로 전환 가능; Cloudflare Turnstile 챌린지는 cf_clearance를 자동으로 기다립니다. 핑거프린트 없는 엔진은 403을 맞지만, 우리는 통과합니다.

  • 🤝 상태 저장 대화형 세션 — 영구 세션 (8분 유휴 keep-alive), 로그인 상태 주입 및 내보내기 가능 (session_create(cookies=...) ↔ session_cookies), 페이지 넘김과 다단계 흐름에서도 유지됩니다. 일회성 엔진은 상태를 버립니다.

  • 🔌 MCP 네이티브 — 14개 도구를 일급 시민으로 제공합니다 (CDP 심(shim)이 아님). Claude Code / Cursor / Claude Desktop이 한 줄로 연결됩니다. HTTP + MCP 이중 프로토콜.

참고: Cloudflare의 Kitesurf는 실제 TLS 핑거프린트 협상도 영구 인증 세션도 명시적으로 제공하지 않습니다 — 봇 방어와 로그인 영역이 바로 AginxBrowser가 활약하는 곳입니다.

Apache-2.0 오픈소스, 단일 바이너리 — 지금 바로 셀프 호스팅, 클라우드 종속 없음.

기능

  • 계층형 렌더링: 일반 HTTP로 정적 페이지 (~100ms); V8은 JS 렌더링이 필요할 때만 시작 (~1-2초) — ~80%의 페이지에서 10배 빠름

  • 멀티 엔진 메타 검색: 일반 웹 (Baidu / Bing / Sogou / WeChat / Google), 뉴스 (Bing News), 코드 (Stack Overflow, GitHub), 패키지 (npm, PyPI), 학술 (arXiv), AI 모델 (Hugging Face) — 동시에 쿼리되고, 병합 및 중복 제거됩니다. 운영자는 동일한 /search에 비공개 Meilisearch 인덱스를 연결할 수 있습니다. 검색 → 읽기가 한 단계로

  • 이미지 검색: categories=images는 Baidu/Bing 이미지 인덱스를 조회하여 직접 바이너리 image_url 링크(jpg/png로 바로 다운로드 가능)와 source_url 출처 정보를 반환합니다

  • 대화형 세션: 인덱싱된 상호작용(state/click/input/scroll/eval)을 지원하는 영구 브라우저 세션 — 에이전트가 인간처럼 브라우징합니다

  • CAPTCHA 자동 해결: 선택적 2captcha 통합을 통한 유형 감지 — 검색이 인증 페이지에서 멈추지 않습니다

  • JS 데이터 추출: js_extract가 SPA에서 window.__INITIAL_STATE__ 및 기타 구조화된 데이터를 추출합니다

  • 스크린샷 렌더링: /screenshot 엔드포인트(옵트인 --features screenshot)가 JS로 렌더링된 DOM을 자체 diting 렌더링 엔진으로 PNG로 그립니다 — 순수 CPU, Chromium 불필요. 에이전트를 위한 시각 입력

  • Cloudflare 자동 대기: "Just a moment..." 챌린지 페이지를 감지하고 cf_clearance를 기다립니다

  • TLS 핑거프린트 스푸핑: 스텔스 모드가 Chrome145/Firefox133/Safari/Edge를 모방하며, 요청별로 전환 가능

  • MCP 서버: --mcp 모드가 14개 도구(fetch/eval/click/search/download + 9개 세션 도구)를 노출합니다 — Claude Code / Claude Desktop / Cursor가 직접 호출

  • Firecrawl 호환: /v1/scrape 엔드포인트 — 기존 Firecrawl 클라이언트는 기본 URL만 변경하면 마이그레이션됩니다

  • DNS 리바인딩 보호: 내장 SSRF 가드 + 해석 후 IP 검증

용도

데모가 아닙니다 — 오늘날 에이전트 브라우저가 실제로 수행하는 작업:

  • 관리 콘솔을 뚫고 진행 — AWS / App Store Connect / Google Play, 작업당 수십 개의 메뉴 레이어. 에이전트가 클릭하게 하세요; 인증이 필요할 때만 다시 호출됩니다.

  • 로그인 뒤에서의 일괄 작업 — 장바구니 채우기, 주문 내역 탐색, 로그인 상태에서만 렌더링되는 페이지 확인. 쿠키를 주입하고, 조작하고, 재사용을 위해 내보내기.

  • 안티봇 장벽 통과 — Cloudflare 보호, Turnstile 챌린지, TLS 핑거프린트 검사. 스텔스 모드는 403에서 후퇴하는 대신 돌파합니다.

  • 중국 인터넷 — 5개 엔진에 걸친 Baidu / Sogou / WeChat 메타 검색, 정확한 중국어 페이지 렌더링. 영어 웹 전용이 아닙니다.

  • 현장 스크립팅 — 에이전트가 페이지를 읽고, JS를 작성하고, 실행합니다: 강조된 비교 테이블, 재배치된 콘텐츠, 숨겨진 매개변수 기반 제품 필터. 스테로이드를 맞은 GreaseMonkey.

  • 멀티모달 비전 — 보고 판단하는 흐름을 위한 시각 입력으로서의 스크린샷: 좌석 선택, 레이아웃 인식, 렌더링 확인.

빠른 시작

호스팅 인스턴스를 먼저 사용해 보세요: https://browser.aginx.net/

원커맨드 전체 설치 (SKILL.md 트리거 서피스 + MCP 도구 + 검증):

# Download -> inspect the contents -> run only after review (never blind-run network scripts)
curl -fsSL https://raw.githubusercontent.com/yinnho/aginxbrowser/main/skill.sh -o skill.sh
less skill.sh
bash skill.sh

MCP만 등록:

claude mcp add aginxbrowser --transport http https://browser.aginx.net/mcp

skills.sh를 통해 스킬 트리거 서피스 설치:

npx skills add yinnho/aginxbrowser

셀프 호스팅:

# Prebuilt binary (one-line installer: platform detect + sha256 + self-check)
curl -fsSL https://raw.githubusercontent.com/yinnho/aginxbrowser/main/install.sh -o install.sh
less install.sh && bash install.sh
aginxbrowser doctor   # features + fonts + egress self-check

# Or build from source (--features stealth,screenshot or you lose both)
cargo build --release --features stealth,screenshot

# Start the service
./target/release/aginxbrowser
# → Listening on 0.0.0.0:8089

# Verify
curl http://127.0.0.1:8089/health
# → {"status":"ok","engine":"diting"}

# Fetch a page
curl -sS -X POST http://127.0.0.1:8089/fetch \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com"}'

# Search
curl -sS -X POST http://127.0.0.1:8089/search \
  -H "Content-Type: application/json" \
  -d '{"q":"macbook price","max_results":5}'

# Create an interactive session
curl -sS -X POST http://127.0.0.1:8089/session/create \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com"}'
# → {"session_id":"s_1","url":"https://example.com/"}

# MCP mode (for AI agents)
./target/release/aginxbrowser --mcp

프로젝트 구조

aginxbrowser/
├── Cargo.toml
├── build.rs              # V8 snapshot generation
├── js/
│   └── bootstrap.js      # V8 bootstrap script
├── README.md
├── docs/
│   └── API.md            # Full API reference (HTTP + MCP)
└── src/
    ├── main.rs              # HTTP service entry & routing
    ├── server.rs            # Business layer (fetch/click/eval/search)
    ├── session.rs           # Interactive browser sessions
    ├── captcha.rs           # CAPTCHA detection & auto-solve
    ├── render.rs            # Tiered rendering (HTTP direct → diting browser engine)
    ├── mcp.rs               # MCP server (14 tools)
    ├── firecrawl_compat.rs  # Firecrawl-compatible /v1/scrape endpoint
    ├── browser.rs           # Top-level API: Browser, BrowserBuilder
    ├── page.rs              # Top-level API: Page, Element
    ├── config.rs            # BrowserConfig
    ├── cookie.rs            # CookieStore
    ├── error.rs             # Error types
    ├── search/              # Native search engines
    │   ├── mod.rs           #   SearchEngine trait, Registry, merge/dedupe, progressive backoff
    │   ├── baidu.rs         #   Baidu (JSON API, wreq stealth)
    │   ├── bing.rs          #   Bing (HTML parsing, plain reqwest)
    │   ├── sogou.rs         #   Sogou web (HTML parsing, plain reqwest)
    │   ├── sogou_wechat.rs  #   Sogou WeChat (HTML parsing + /link resolution)
    │   ├── google.rs        #   Google (HTML parsing, wreq stealth + proxy)
    │   ├── stackexchange.rs #   Stack Overflow (SE API v2.3, code category)
    │   ├── github_repos.rs  #   GitHub repos (api.github.com, code category)
    │   ├── arxiv.rs         #   arXiv (Atom API, academic category)
    │   ├── bing_news.rs     #   Bing News RSS (news category; proxy-first)
    │   ├── huggingface.rs   #   HF Hub models/datasets/spaces (ai category)
    │   ├── npm.rs           #   npm packages (npms.io API, packages category)
    │   ├── pypi.rs          #   PyPI name resolution (JSON API, packages)
    │   └── meilisearch.rs   #   Private-index adapter (env-configured)
    │
    ├── diting_dom/          # HTML parsing, DOM tree, CSS selectors
    ├── diting_net/          # HTTP client, cookies, encoding, proxies
    ├── diting_js/           # V8 runtime, JS ops, module loading
    └── diting_browser/      # Page navigation, lifecycle, browser context

빌드

# Standard build (no stealth; TLS fingerprint features inactive)
cargo build --release

# With stealth (requires go + cmake + C++ toolchain; enables TLS fingerprint spoofing)
cargo build --release --features stealth

# With screenshot rendering (enables /screenshot; adds the rendering stack, +30-40MB)
cargo build --release --features screenshot

# Full featured (recommended for production)
cargo build --release --features stealth,screenshot

요구 사항: Rust 1.78+; V8 정적 라이브러리는 첫 빌드 시 자동으로 다운로드됩니다. 스텔스 기능은 추가로 go, cmake, C++ 컴파일러가 필요합니다. 스크린샷 기능은 번들된 CJK 글꼴 하위 집합(GB2312 + 공통 기호)을 포함합니다 — 정확한 중국어 렌더링에 시스템 글꼴이 필요 없습니다.

런타임 환경 변수

Variable

Default

Description

AGINXBROWSER_BIND

0.0.0.0:8089

수신 주소

AGINXBROWSER_STEALTH

enabled

0은 스텔스 모드를 비활성화합니다 (진단용)

AGINXBROWSER_UA

Linux Chrome145

스푸핑된 User-Agent

AGINXBROWSER_ACCEPT_LANGUAGE

zh-CN,zh;q=0.9,en;q=0.8

Accept-Language 헤더

AGINXBROWSER_PROXY

none

선택적 폴백 프록시. 차단된 소스 엔진(Google, Bing News, Hugging Face)은 먼저 직접 연결을 시도하고 직접 연결이 실패할 때만 이 프록시로 폴백합니다 — 해외 배포는 프록시가 전혀 필요 없습니다. 요청별 use_proxy:true는 fetch/search도 이를 통해 라우팅합니다

AGINXBROWSER_CACHE_TTL_SECS

600

/fetch 캐시 TTL, 0은 비활성화

CAPTCHA_SOLVER_API_KEY

none

2captcha API 키. CAPTCHA 자동 해결 활성화

CAPTCHA_SOLVER_SERVICE

2captcha

CAPTCHA 해결 제공자

AGINXBROWSER_MEILI_URL

none

Meilisearch 기본 URL. 설정 시 개인 인덱스 엔진 활성화

AGINXBROWSER_MEILI_INDEX

none

쿼리할 Meilisearch 인덱스 uid

AGINXBROWSER_MEILI_KEY

none

Meilisearch 인스턴스용 선택적 Bearer 키

API 문서

전체 API 참조 → docs/API.md 보안 감사 노트 → docs/skills-sh-audit.md — skills.sh가 "Critical Risk"를 표시하는 이유와 각 경고가 대응하는 실제 제품 기능

포함 내용:

  • 모든 HTTP 엔드포인트 (/fetch, /click, /eval, /search, /v1/scrape, 8개 세션 엔드포인트)

  • 14개 MCP 서버 도구 전체와 해당 매개변수

  • Claude Code / Claude Desktop / Cursor 클라이언트 구성

  • 환경 변수, 오류 코드, 사이트별 스크래핑 예제

다른 시스템에 연결

AginxBrowser는 순수하게 곁에 붙는 인프라입니다 — 실제 브라우저처럼 호스트 코드를 임베드하거나 호스트 구성을 오염시키지 않으면서 무엇이든 호출할 수 있는 독립적인 서비스로 실행됩니다. 머신당 하나의 인스턴스(systemd 하에서)를 배포하면 "render + scrape" 기능이 필요한 모든 앱이 이를 공유합니다.

통합: 환경 변수 AGINXBROWSER_URL=http://127.0.0.1:8089를 읽습니다. 미설정 → 동작 변경 없음; 설정 → 위험 관리 대상 사이트가 렌더링을 위해 AginxBrowser를 통해 자동으로 라우팅되며, 실패 시 정상적으로 폴백합니다.

알려진 제한 사항

  1. 스크린샷은 옵트인: /screenshot은 cargo build --release --features screenshot이 필요합니다 (렌더링 스택 추가, +30-40MB). 기본 렌더 엔진은 diting(자체 CSS+레이아웃+페인트 스택)입니다. engine: "blitz"를 전달하면 Blitz 참조 파이프라인으로 다시 옵트인할 수 있습니다. 복잡한 사이트의 CSS는 둘 다 근사치입니다 (Chromium처럼 픽셀 단위로 완벽하지 않음)

  2. 요소 좌표 지원(블록 수준): selector가 있는 /screenshot은 요소 페이지 좌표(selector_rects, CSS px)를 반환합니다. selector만 사용하면 해당 요소로 바로 크롭합니다. 순수 인라인 요소(<a>text</a>)는 독립적인 박스가 없습니다 — 블록 조상을 선택하세요

  3. JS 상호작용은 대체로 작동하지만, 지문 감지가 심한 페이지는 여전히 실패할 수 있습니다: React/Vue 이벤트 위임은 정상적으로 작동합니다 (src/href 같은 URL 반영 속성은 절대 URL로 해석되어 Next.js/webpack이 하이드레이션하고 클릭이 핸들러를 트리거합니다). navigator.plugins, WebGL canvas 등을 탐지하는 지문 감지가 심한 인증 페이지(WorkOS/Cloudflare)는 스텔스 지문 커버리지가 완료될 때까지 여전히 실패할 수 있습니다

  4. 프록시 지원: AGINXBROWSER_PROXY를 통한 HTTP/HTTPS/SOCKS5

  5. 위험 관리가 까다로운 사이트: Baidu Wenku는 지원되지 않습니다. Zhihu 기사는 유효한 __zse_ck가 필요합니다

라이선스

OpenCarrier 메인 프로젝트와 일치합니다. Apache-2.0.

Available Tools

40 tools
account_deleteAInspect

Delete a named login identity: stored record AND live jar. Cookie values are credentials — delete means gone. Sessions currently running as the account keep their in-process jar handle, but nothing writes back. Returns {deleted: name}, or an error naming the account if it does not exist.

Inputs: name (required).

account_listA
Read-only
Inspect

List named login identities (the multi-account layer) with metadata only: name, cookie domains, cookie count, updated_at, the last account_verify verdict, and the identity's persona User-Agent (each account is one stable device: its own UA and hardware fingerprint, drawn once and reused). Cookie values are credentials and never leave the server. Use to see which identities exist before session_create {account} picks one.

Inputs: no named parameters.

account_loginAInspect

Open a site's login page AS a named account and close the login loop. Creates the session as the account (private jar, device persona), navigates to url, and reports which generic login gates the page shows — needs: password | sms | qr | slider (QR scan like xiaohongshu, SMS code, password form, slider/captcha) — plus a session_verdict classification and, when a human step is needed, the session_id and a /live handoff so a person can finish it in the live view (the engine detects and describes; it never fills credentials or solves challenges). With predicate and no human gates detected, waits for the automatic bounce, then teaches + stamps the account's verify spec — later account_verify calls re-check it bare. Cookies write back after every action, so a login finished in /live is already persisted. status is "logged_in" (verify stamped), "waiting" (drive session_wait/session_input on session_id, or re-call account_login after the human finishes — the account's shared jar already holds it), or "opened" (no predicate given).

Inputs: url (required), name (required), predicate, use_proxy, +1 more.

account_verifyAInspect

Check whether a named account is still logged in. Teach-once: the first call passes url + predicate (a JS expression truthy on a logged-in page, e.g. !!document.querySelector('.user-nick')); the spec is remembered and later calls can be bare. Runs in a scratch session AS the account (private jar), so the probe doubles as a cookie refresh. Returns {name, logged_in, url, checked_at}.

Inputs: name (required), url, predicate.

cacheAInspect

Query the LOCAL CACHE of every page this server has fetched and every search it has run. Check here BEFORE re-fetching or re-searching — a hit is instant and free while a fresh fetch costs 5-60s. Use query for full-text search (works for Chinese substrings and English words), get to pull a page's full cached content, stats for counts, clear to delete rows.

Inputs: all, get, url, kind, +5 more.

clickAInspect

Click an element on a one-off page: loads url in a fresh browser context (stateless — no cookies unless passed, no shared state with other calls), waits wait_secs after load before clicking, then fires a DOM click on the first CSS-selector match. The click may trigger navigation (link, form submit) — the response url and text_after are read after that navigation lands. Returns clicked:false when the selector matches nothing. For multi-step interaction on a shared page use session_click instead.

Inputs: url (required), selector (required), wait_secs.

downloadAInspect

Download a file over HTTP(S) with streaming to disk (no memory buffering), SHA-256 integrity hash, and optional resume of interrupted transfers. Filename resolution: explicit param → Content-Disposition → URL tail. Use for binaries, archives, datasets, documents - anything where the agent wants the FILE saved, not its text content read.

Inputs: url (required), resume, cookies, filename, +1 more.

evalAInspect

Execute JavaScript on a one-off page: loads url in a fresh browser context, optionally waits wait_secs for the page to settle, evaluates script (async/Promise supported) and returns {url, result}. Script-driven navigation (location.href, form submit) is drained and reflected in the returned url. Stateless — no cookies or page state shared with other calls; when the script needs prior page state or a login, use session_eval.

Inputs: url (required), script (required), wait_secs.

fetchA
Read-only
Inspect

Fetch a webpage and return clean markdown/html/text. Use whenever the agent needs to READ any web page - blogs, docs, articles, JS-rendered SPAs, Cloudflare-protected sites. Static pages are served over plain HTTP (~100ms tier:"http"); pages that need JS get the full browser (tier:"browser"). render_tier selects auto (default) / http (pure HTTP, refuses the upgrade) / browser (always the JS browser).

Inputs: url (required), format, sanitize, selector, +8 more.

flow_runAInspect

Run a flow — a recorded, editable JSON browser-session script — deterministically, with zero model tokens. Steps are {op, args, expect?, save?}: ops cover navigate/click/click_xy/input/scroll/eval/wait/screenshot/state/cookies; {{var}} placeholders in args are filled from vars; expect asserts (url_contains | selector | text_contains | eval_truthy) abort with evidence on failure; save collects a step's output into the receipt. Source the flow inline via "flow", or by "name" from the server's workflow//flow.json (unknown name → error lists installed workflows). Pass session_id to reuse a live session (e.g. from import_curl) so login state and flows compose. The receipt carries status ok/failed, saved outputs, the session_id (kept alive), and on failure the failing step, reason and a diagnostic screenshot — fix the flow or take the session over from there.

Inputs: flow, name, vars, max_steps, +1 more.

import_curlAInspect

Import login state from a real browser in one paste. The human logs into a site in their own Chrome (solving the CAPTCHA/SMS once), opens DevTools → Network, right-clicks any authenticated request → "Copy as cURL", and passes the command here. Returns a live session_id already carrying that site's cookies and sitting on the copied request's URL — the agent continues from where the human left off, no password or second login needed. Works with bash, PowerShell and cmd copy flavors.

Inputs: curl (required), account, use_proxy.

render_markdownAInspect

Render a markdown document into a deterministic, self-contained HTML artifact - the document layer, so the agent never writes HTML by hand. Prose rides a plain offline shell (no fonts, no scripts); archify fenced code blocks carry typed zero-coordinate diagram JSON (sequence, workflow, architecture, dataflow, lifecycle families) and render to inline SVG via the layout engine. Same input, same bytes: the receipt carries the sha256 so determinism is verifiable. theme picks light (default) or dark; preset picks the palette family — classic (default), signal-flow, blueprint, editorial — orthogonal to theme; colors bake at generation time (presentation attributes, not CSS variables), and the receipt records both preset and theme. quality picks the composition audit profile — standard (default) or showcase, the delivery gate: the receipt's diagrams[].composition grades route crossings, ambiguous corridors, label clearance (2px standard / 4px showcase), route rhythm, and node text projected to the 930px reader width; the audit never changes the artifact bytes. Mermaid sources are the agent's job to translate, not the engine's: flowchart/graph → workflow (lanes + columns), sequenceDiagram → sequence, stateDiagram-v2 → lifecycle (bands), erDiagram/class → architecture (grid + boundaries) — read the topology and emit the matching zero-coordinate archify JSON; the engine accepts only archify JSON. A broken diagram degrades to a visible code block and lands in receipt.diagnostics; an authored route preset that cannot be honored is self-repaired to a verified semantic substitute and disclosed in receipt diagrams[].repairs - the document still renders. A fence may also carry views: [{id,label,nodes,note?}] (node ids of the active family), emitted as guided-view tabs above the diagram plus an inlined viewer script - clicking a tab lights the member nodes and the routes between them (subgraph), clicking a node lights it with its direct neighbors (ego graph), everything else dims; a view's optional note shows as a caption while it is active (the story layer). window.agxViewer in a session drives and reads the same state programmatically: {focus,view,state} as before, plus route(i,from,to) which returns and lights the shortest authored directed path between two nodes (null when unreachable, state untouched), and reach(i,id,down|up) which returns and lights the authored downstream/upstream closure ({nodes,links}); both dim the rest of the diagram. diagrams[].views in the receipt lists the tabs. motion: true bakes an entrance choreography into the artifact: pure-declarative CSS animation with zero scripts - headings split into per-glyph (CJK) / per-word (latin) spans that rise in with expo easing, prose blocks stagger up an nth-child delay ladder, diagram figures grow in with a back ease (GSAP's easing math as public cubic-bezier equivalents, nothing embedded); the diagrams themselves play a flow story on the same clock - nodes land beat by beat, solid edges draw in (dash-offset), dashed returns fade, sequence messages arrive as sent - with a timed caption strip under each figure as the subtitles, which becomes a static transcript under prefers-reduced-motion; the file itself animates in any browser and the receipt records motion plus diagrams[].story (beat times and captions - the hook for muxing voice later). With session_id the artifact is also loaded into that session (local, free) and the reply carries viewport acceptance: scroll extents measured in the live session and graded fits/tall/wide/oversized, telling the agent how to read the page back. Diagram vocabulary adapted from archify (MIT).

Inputs: markdown (required), theme, motion, preset, +2 more.

render_pdfAInspect

Cut a rendered page into pages and package as PDF, PNGs, PPTX or DOCX. Print mode (no selector) paginates the document into fixed-height pages (default 794x1123, A4 @96dpi), breaking at top-level block boundaries — no half-cut text where a break can land on a block edge. Slides mode (selector set) makes one page per match, sized to that element — generate an HTML deck with one .slide per page and each becomes a deck page. format "pdf" (default) returns base64 image-based PDF; "png" returns one base64 PNG per page in pages_base64; "pptx" returns a base64 PPTX (one slide per page, deck-sized to the largest page); "docx" returns a base64 DOCX (one page-sized section per page, each section keeps its own height). Returns page count and packaging.

Inputs: url (required), width, format, height, +5 more.

render_videoAInspect

Render a page's animation timelines to an MP4 video. The page's scripts must expose window.__timelines — objects with duration() and pause(t) (a paused gsap.timeline registered there works as-is). Each frame seeks every timeline to t=i/fps and paints the viewport, so the output is deterministic — no wall clock in the pixel values. Audio: narration[] places TTS/voice clips at start times (mixed into one AAC track), audio adds looped background music, and subtitles_srt muxes an SRT as a soft mov_text track and (by default, burn_subtitles: false to opt out) burns the same cues into the frame pixels — QuickTime, WeChat and most social embeds ignore the soft track. Requires ffmpeg on the server. Returns base64 MP4 (H.264, yuv420p) plus frame count and durations.

Inputs: url (required), fps, audio, width, +10 more.

session_challengesA
Read-only
Inspect

One-call risk-control report: did this session hit an anti-bot wall? Taobao/tmall's x5 risk control answers 200 like a normal response — either a redirect onto a punish page (tmd/punish, punish.taobao.com) or an MTop API body carrying FAIL_SYS_USER_VALIDATE / RGV587 / x5secdata. Returns {total, events:[{url,method,status,kind,via}]} where via says whether the wall was navigated into ("url") or swallowed by an API response ("body"). When there are hits, the response also carries the account name (which identity got walled) and a handoff instruction: the engine detects and surfaces but does not auto-bypass — a human opens the live view (/live?session= on the engine's HTTP port), solves the challenge in this session, and the retry rides the cookie that solving sets. Detection only; no automated solving or bypass.

Inputs: session_id (required).

session_clickAInspect

Click an interactive element by its index (from session_state output) inside a live browser session: scrolls it into view and fires a DOM click on the session's current page. Before clicking it re-verifies the element in the same frame — if the page changed since session_state (element detached, disabled, hidden, or covered by an overlay), it returns clicked:false with a reason ("detached"/"disabled"/"not_visible"/"covered_by") and, when covered, a covered_by description of the element that would eat the click — never a silent no-op. A submit click may navigate the session — the returned url/text_after reflect the page after the action, and session state (cookies, localStorage, globals) persists for follow-up calls. Indexes come from the most recent session_state; re-list after navigation.

Inputs: index (required), session_id (required).

session_click_xyAInspect

Click at viewport coordinates (CSS pixels) via real mouse events — pointerdown/mousedown, pointerup/mouseup, then click on whatever element is hit there. For canvas/map surfaces with no DOM element to index. click_count 2 adds dblclick.

Inputs: x (required), y (required), session_id (required), button, +1 more.

session_cloneAInspect

Derive a new browser session from a live one, carrying the full login state: cookies, localStorage/sessionStorage, viewport pin, dialog policy, proxy and keepalive flags. The source session stays untouched. Use to snapshot a logged-in state before risky actions, or to run the same login in parallel tabs. Returns {session_id (new), cloned_from, url, viewport}.

Inputs: session_id (required).

session_closeAInspect

Close a browser session and free its resources. For a persistent session this also drops the on-disk login snapshot - idle expiry keeps it, an explicit close does not.

Inputs: session_id (required).

session_consoleA
Read-only
Inspect

Read the session's recent page console output (log/info/warn/error) as {url, total, matched, messages:[{ts_ms, level, text, url}]}, newest last. Ring buffer of 500 entries; captures output from page scripts, clicks, evals and navigation alike. Optional filters: level (exact, e.g. "error"), since_ts (epoch ms), url_contains (page URL substring), limit (most recent N matches). The fastest way to see WHY a page misbehaves: click the button, call this, read the error.

Inputs: session_id (required), level, limit, since_ts, +1 more.

session_cookiesA
Read-only
Inspect

Export the session's current cookies as ["name=value", ...] for the page's URL. Use to persist a logged-in session and replay it later via session_create with cookies. Round-trips with session_create's cookies field.

Inputs: session_id (required).

session_createAInspect

Create a persistent interactive browser session for multi-step interaction - clicking, typing, scrolling, reading state across page transitions. Use when the agent must INTERACT with a page (login flows, forms, pagination, click-through) rather than read it once. Returns session_id; persists 8 min idle. With persistent:true the login state survives idle eviction and server restarts - the same session_id revives logged-in.

Inputs: url, width, height, mobile, +7 more.

session_dialogAInspect

Inspect or flip the session's dialog policy for window.alert/confirm/prompt. Dialogs never block the page: each is auto-answered (default dismiss) and logged into session_console at level "dialog". action "list" reports {policy, prompt_text, dialogs}; "accept" makes subsequent confirm() true and prompt() return prompt_text (or the call's default argument); "dismiss" restores the default.

Inputs: action (required), session_id (required), prompt_text.

session_dragAInspect

Drag the mouse from one viewport position to another: press at from, steps mousemove events, release at to. The trajectory is humanized by default (eased velocity, wobble, jittered timing, overshoot) — the shapes anti-bot checks score for; pass humanize:false for exact linear interpolation. Moves AMarker-style drag targets, canvas selections and captcha sliders that only track while the pointer travels.

Inputs: to (required), from (required), session_id (required), steps, +2 more.

session_evalAInspect

Execute arbitrary JavaScript in a live browser session and return the result. Runs in the session's current page, so DOM mutations, globals and storage persist across calls — unlike the stateless eval tool, which loads its own throwaway page each call. Script-driven navigation moves the session's URL. JS exceptions are reported with name, line/column and stack.

Inputs: script (required), session_id (required), timeout_ms.

session_exportA
Read-only
Inspect

Export a browser session's recorded action log. Format "bash" (default) returns a runnable curl script that replays every recorded action (navigate/click/input/scroll/eval) against a fresh session on this server — hand it to a shell or cron, zero model tokens. Format "jsonl" returns the raw action log, one JSON object per line. Format "json" returns a flow.json document — the same recording as editable ops ({op, args}) with cookies/storage stripped — that flow_run replays server-side.

Inputs: session_id (required), format.

session_inputAInspect

Type text into an input/textarea element by its index (from session_state output), focusing it and dispatching input/change events. events:"full" is the complete human typing gesture: per-character keydown/keypress/input/keyup cycles, trailing change, then blur — the tail blur commits on forms that save in onBlur (React capture listeners, #100). A disabled, readonly, or detached field answers filled:false with a reason instead of a silent write. Hidden inputs are legitimate targets and are filled normally.

Inputs: text (required), index (required), session_id (required), events.

session_listA
Read-only
Inspect

List live browser sessions with idle age and the time left before auto-eviction. Use to discover a session to reuse instead of creating a new one; sessions expire after 8 min idle.

Inputs: no named parameters.

session_navigateAInspect

Navigate a browser session to a new URL.

Inputs: url (required), session_id (required).

session_networkA
Read-only
Inspect

Read the session's network request log. filter="media" extracts playback/stream URLs (m3u8/HLS, mp4, dash, flv...) actually requested by the page's player at runtime - the reliable way to get a real video link, since links embedded in page HTML are often decoys. Media elements and player iframes the engine never fetches (video/audio/source/iframe src) are merged in as candidates: via="network" entries are confirmed requests, via="dom" entries are candidates carrying their tag (iframes = kind "iframe", navigate into them to sniff). Default returns every request as compact rows (method/url/status/type/size). Navigate to the video page first, let it load, then call this.

Inputs: session_id (required), filter, url_contains, body_max_chars, +1 more.

session_preloadAInspect

Replace the session's document-start preload group (empty array clears). Sources run before each new document's own scripts — including inline tags — which is the only hook that beats pages whose signing layer captures window.fetch/XHR natives at parse time (xhs's inline jsvmp). Set before the first navigate; applies to every navigation from then on.

Inputs: session_id (required), scripts.

session_screenshotAInspect

Screenshot the session's CURRENT DOM state (mutations from clicks/evals included) as a base64 PNG via the built-in renderer. Width/height default to the session's viewport, so session_viewport + session_screenshot shows the responsive layout. Returns {url, width, height, image_base64, format}.

Inputs: session_id (required), width, height, selector, +2 more.

session_scrollAInspect

Scroll the page up or down by a number of viewport-heights.

Inputs: session_id (required), amount, direction.

session_set_filesAInspect

Select files on a file input programmatically (Playwright setInputFiles semantics): builds File objects from base64 content, assigns them to input.files, then dispatches input+change so framework onChange handlers fire. Selector-addressed because file inputs are often hidden and absent from the session_state index.

Inputs: files (required), selector (required), session_id (required).

session_stateA
Read-only
Inspect

Get the current page state as an indexed list of interactive elements. Returns compact text with [N] indexes for use with click/input tools.

Inputs: session_id (required).

session_storageA
Read-only
Inspect

Snapshot the session's localStorage/sessionStorage for the current origin: {url, local_storage, session_storage}. Feed it back via session_create's storage field to restore a logged-in state in a new session — the half of login state that cookies can't carry (many sites keep the session token in localStorage). Call before the session idles out.

Inputs: session_id (required).

session_verdictA
Read-only
Inspect

One call answers "where did this session land": verdict is one of challenge (risk control engaged — punish page or a 200-status API body that swallowed the wall; the response carries a handoff instruction for a human to solve it in the live view), captcha (explicit CAPTCHA interstitial), login (bounced to a login form — auth expired), empty, landed (normal 2xx content page), or unknown (couldn't classify — read facts; a non-2xx main document lands here with facts.doc_status carrying the number, so a zhihu-style burst 403 is branchable). The facts sheet also carries challenge_events, requests, console_errors and the fired signals. Pure code over signals the engine already holds (current URL, risk-control rows, main document status/size, console errors) — no screenshots, no page evals, single-digit milliseconds. Verdict observes, it never bypasses.

Inputs: session_id (required).

session_viewportAInspect

Set the session's viewport (device emulation): scripts see innerWidth/innerHeight move, media queries like (max-width: 600px) re-evaluate, element rects re-anchor, and mobile=true flips pointer/hover matchMedia answers to coarse/none. Omitted width/height keeps the current value.

Inputs: session_id (required), width, height, mobile.

session_waitA
Read-only
Inspect

Wait until a CSS selector matches or a JS predicate turns truthy, with a timeout. The page's event loop keeps running while waiting (fetches, timers, promise chains progress), so this replaces blind sleeps for async content: navigate, session_wait for '.price-card', then click/read. Returns {matched, elapsed_ms, detail:{tag,text} or the predicate value}; errors with timeout ... naming the selector/predicate on expiry. Exactly one of selector/predicate.

Inputs: session_id (required), selector, predicate, timeout_ms.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 40 tools

    Disambiguation4/5

    Tool families are cleanly separated: stateless fetch/eval/click are explicitly distinguished from their session_* counterparts, and account_*/render_*/session_* names signal intent. The main fuzzy boundaries are session_challenges vs session_verdict (both report anti-bot/risk status) and the three render_* tools, though descriptions usually resolve them.

    Naming Consistency4/5

    Most tools follow predictable families—account_<verb>, session_<operation>, render_<format>—and bare stateless verbs (fetch, search, eval, click) are easy to read. Deviations such as flow_run instead of run_flow and noun-style read tools like session_state/session_network/session_cookies keep it from being perfectly uniform.

    Tool Count2/5

    40 tools is a heavy surface, especially with 26 session_* variants; even though each is a real browser action, the set will tax an agent's selection and context budget. The server's broad scope explains the count, but it still exceeds what most MCP clients handle gracefully.

    Completeness4/5

    The surface covers the full browser workflow: read/search/download, session lifecycle and input, login-state persistence, risk-control verdicts, flow replay, and render/export targets. Minor gaps such as no explicit multi-tab/window management or standalone proxy/user-agent configuration are workaroundable.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Browser automation MCP server that uses a real browser to give agents eyes and hands—open pages, click, fill, screenshot, and run scripts via accessibility-tree snapshots.
      22
      6 npm
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables AI agents to run Playwright-compatible browser automation with persistent profiles, proxies, Chrome extensions, and humanized mouse, keyboard, and scroll interactions over stdio or Streamable HTTP. Supports web research, daily automation, testing workflows, and optional session-scoped CDP access.
      280 npm
      MIT