Skip to main content
Glama

nullprint-mcp

An MCP server for Nullprint, the AI antidetect browser. It lets any MCP-capable AI agent (Claude Code, Claude Desktop, OpenAI Codex, Kimi, …) create browser profiles, launch them, run consistency check-ups and drive the pages inside a running profile.

The server is a thin layer over the local Nullprint daemon's HTTP API: every tool maps to one daemon endpoint. The daemon, the browser kernels and the fingerprint engine ship with the Nullprint desktop app and are not part of this package.

Requirements

  • Nullprint desktop app installed and running (Windows or macOS), signed in. Download: https://nullprint.ai

  • Python 3.11+ on the same machine. The easiest way to run the server is uv, which installs the package on first use.

Related MCP server: gotham-browser

Install

# Claude Code
claude mcp add nullprint -- uvx nullprint-mcp

# OpenAI Codex
codex mcp add nullprint -- uvx nullprint-mcp

Claude Desktop, Kimi and other clients that use an mcpServers config file:

{
  "mcpServers": {
    "nullprint": {
      "command": "uvx",
      "args": ["nullprint-mcp"]
    }
  }
}

Without uv: pip install nullprint-mcp, then use nullprint-mcp as the command (no args).

No port or key to configure: the server reads the running daemon's port and API key from ~/.nullprint/daemon.json, which the desktop app writes on start-up. To point at a daemon elsewhere, pass --daemon-url http://host:port (or --port 7801 for localhost) and set NULLPRINT_API_KEY. Resolution order, most explicit first:

  1. --daemon-url / --port

  2. NULLPRINT_DAEMON_URL

  3. NULLPRINT_PORT

  4. ~/.nullprint/daemon.json (NULLPRINT_HOME changes the directory)

If the daemon is not running the tools say so plainly instead of throwing a connection trace.

Tools

Tool

What it does

Daemon endpoint

profiles_list

List every profile with status (running / idle), exit and ledger metadata

GET /profiles

profile_start

Open a browser session for a profile; returns the driving endpoints

POST /sessions/{name}

profile_stop

Stop that profile's browser (session or app-launched window)

DELETE /sessions/{name} → falls back to POST /profiles/{name}/stop

profile_create

Create a profile (fingerprint generated and frozen), optionally with proxy, ledger and start pages

POST /profiles

profile_settings

Change a display setting of an existing profile — today force_dark (force dark web pages, off by default; merged into its launch settings)

GET + PATCH /profiles/{name}

profile_checkup

Consistency check-up, returns {summary, checks}

GET /profiles/{name}/checkup?live=

proxy_check

Stateless proxy test: exit IP, country, latency

POST /proxy-check

profile_delete

Soft delete to the recycle bin (recoverable); refused while running

DELETE /profiles/{name}

trash_list

Read-only list of recoverable profiles in the recycle bin

GET /trash

profile_restore

Restore from the recycle bin with fingerprint, proxy and logins intact

POST /trash/{name}/restore

session_goto

Navigate the session's current page

POST /sessions/{name}/goto

session_snapshot

Accessibility tree of the current page (find selectors, read state)

GET /sessions/{name}/snapshot

session_screenshot

Screenshot of the current page as an image (full_page optional; size-capped)

GET /sessions/{name}/screenshot

session_click_selector

Click an element by CSS selector (nth picks one of several matches)

POST /sessions/{name}/click_selector

session_fill_selector

Fill an input by CSS selector (nth picks one of several matches)

POST /sessions/{name}/fill_selector

session_press

Send a key (e.g. Enter)

POST /sessions/{name}/press

session_eval

Run JavaScript on the page, returns {ok, result}

POST /sessions/{name}/eval

session_tabs

List the session's tabs and the active one

GET /sessions/{name}/tabs

session_switch_tab

Bring a tab to the front

POST /sessions/{name}/switch_tab

session_dialog

Answer the JavaScript dialog (alert / confirm / prompt / beforeunload) open on the page: accept or dismiss

POST /sessions/{name}/dialog

Notes that matter when writing prompts:

  • session_* tools need an open session. They drive the warm session opened by profile_start; calling them on a profile without one returns 409. Selectors are CSS, not XPath or role/name; call session_snapshot first when you do not know a selector.

  • Selectors must match one element. If a selector matches several, session_click_selector / session_fill_selector fail with "matched N elements"; write a more specific selector or pass nth (0-based).

  • session_screenshot is size-capped and needs Nullprint 0.2.31+. Shots are in CSS pixels (older apps shoot at screen pixels, doubled on high-DPI displays), at most 2000 px on the longest side: a bigger full page comes back as the viewport, a bigger viewport is an error asking for a smaller window, and a PNG over 1 MB comes back as JPEG; the returned info says so. Use session_snapshot to read text, the screenshot to see layout.

  • Dialogs are left open, as in a normal browser. While an alert / confirm / prompt is open the page is blocked and session_* tools fail with 409 naming the dialog; answer it with session_dialog, then retry. A beforeunload caused by your own session_goto or click is accepted automatically.

  • session_eval returns an envelope. A page-side JavaScript error comes back as data ({ok: false, error, error_type}), not as a tool failure; result follows the expression's type.

  • profile_stop has two levels. A profile can be "running" as a warm session or as a window launched from the app. The tool tries the session first and falls back to the app-level stop, which is idempotent for idle profiles. It returns {name, stopped, closed}.

  • profile_create does not hard-code a kernel. Leave engine empty to use the app's default; unknown values come back as a 422 listing the options.

  • proxy_check failures are data. An unreachable proxy returns {ok: false, error}; only an unreachable daemon raises.

  • profile_start returns cdp_endpoint (a ws:// DevTools address) for Chrome kernels with external debugging turned on in the app (off by default; Edit → Advanced → External debugging, needs a second verification, then reopen the profile), so external tools can attach. Otherwise it is null, with cdp_unavailable (reason code) and cdp_note saying why. A session driven from outside bypasses Nullprint's consistency guards: an outside tool can set a viewport, language or time zone that contradicts the profile's frozen fingerprint and make it detectable. Prefer the session_* tools; if you must attach, do not change anything the profile has not declared.

Give the agent the Nullprint tools, not your shell

This server reads the daemon's port and API key from ~/.nullprint/daemon.json. Any program running as the same OS user can read that file too, including an AI agent that is allowed to run shell commands or read files. With the key it can call the daemon's HTTP API directly, outside the tools listed here (and outside what this server deliberately leaves out). We saw it happen while recording our own demo: when the agent could not do what it wanted with the tools, it read daemon.json on its own and sent requests with that key. When an agent drives Nullprint, allow only the Nullprint tools (in Claude Code, the mcp__nullprint__* tools) and keep shell and file-reading tools off, or approve each such call yourself.

What is deliberately not exposed

Permanently deleting a profile (DELETE /trash/{name}) destroys its logins and cannot be undone. It is not a tool on purpose: emptying the recycle bin is a human action in the desktop app. profile_delete's description tells the agent to say so instead of working around it, and a test scans every tool's source to keep the purge endpoint out. Screenshot-to-disk and file-writing tools are left out for the same reason (local path safety); session_screenshot returns the image inline and writes nothing.

Development

pip install -e ".[dev]"
pytest tests
nullprint-mcp --help

Tools live in nullprint_mcp/tools.py (the TOOLS tuple); server.py and __main__.py do not change when a tool is added. Nothing may be printed to stdout: stdout is the MCP channel.

License

MIT. Copyright (c) 2026 HENGCHENG LLC.


中文说明

这是 Nullprint(AI 指纹浏览器)的 MCP 服务:Claude Code、Claude Desktop、OpenAI Codex、Kimi 等任何支持 MCP 的 AI 都可以用它建身份、启动浏览器、做一致性体检、驱动身份里的网页。它只是本地 daemon HTTP 接口上的薄薄一层,每个工具对应 daemon 的一个端点;daemon、浏览器内核和指纹引擎随 Nullprint 桌面应用发布,不在本包内。

前提:本机装好并登录 Nullprint 桌面应用;本机有 Python 3.11+,推荐用 uv(首次运行自动装包)。

接入:

claude mcp add nullprint -- uvx nullprint-mcp      # Claude Code
codex mcp add nullprint -- uvx nullprint-mcp       # OpenAI Codex

Claude Desktop、Kimi 等走配置文件的客户端,在 mcpServers 里加 {"command": "uvx", "args": ["nullprint-mcp"]}。没有 uv 就 pip install nullprint-mcp,命令改为 nullprint-mcp。

不用配端口和密钥:服务自动读桌面应用写在 ~/.nullprint/daemon.json 里的端口和 API Key。要连别的机器上的 daemon,传 --daemon-url 并设 NULLPRINT_API_KEY。

20 个工具:profiles_list、profile_start、profile_stop、profile_create、profile_settings、profile_checkup、proxy_check、profile_delete、trash_list、profile_restore,以及 10 个会话工具 session_goto / snapshot / screenshot / click_selector / fill_selector / press / eval / tabs / switch_tab / dialog(先 profile_start 再用)。session_screenshot 直接回图片(需要 Nullprint 0.2.31 及以上)(可整页,按 CSS 像素、长边不超过 2000 px:整页超了退回可视区域,可视区域超了报错请你把窗口改小,超过 1 MB 改 JPEG,不落盘);选择器匹配到多个元素时报「matched N elements」,写得更具体或传 nth(从 0 数)。彻底删除身份故意不做成工具:清空回收站只能在桌面应用里由人操作。

只把 Nullprint 工具放行给 AI:本服务从 ~/.nullprint/daemon.json 读 daemon 的端口和 API Key;MCP 客户端和 daemon 跑在同一个系统用户下时,这个文件同一用户的任何程序都能读到,包括被允许跑命令、读文件的 AI。拿到 Key 就能绕过这里的工具直接调 daemon 的 HTTP 接口(包括本服务故意不开放的)。我们自己录演示时就遇到过:AI 用工具做不到想做的事,自己去读了 daemon.json,拿 Key 发请求。让 AI 操作 Nullprint 时,只放行 Nullprint 的工具(Claude Code 里是 mcp__nullprint__*),命令行和读文件类工具关掉,或者每次由你自己批准。

Available Tools

20 tools
profile_checkupA

Run the consistency checkup on an identity — is its fingerprint coherent?

This is the check competitors cannot make: every trait has one correct value given the identity's OS, browser core, and exit IP, so each item gets a verdict rather than just being displayed. Run it after changing an identity's proxy, and before trusting an identity with anything that matters.

Args: name: identity name, exactly as profiles_list reports it. live: False (default) derives everything from the stored record — fast, no side effects. True additionally STARTS THE BROWSER to measure the real TLS/JA3 fingerprint and User-Agent against the browser core's baseline. That takes tens of seconds and opens a window, so use it when you actually need measured proof, not for a routine look.

Returns {name, engine, live, summary, checks}. summary is "pass", "warn", or "fail" — the worst verdict among the checks. Each entry in checks has an id, a label, a verdict ("pass"/"warn"/"fail"/"skip"), and a detail string explaining it. "skip" means the check needs live=True, or does not apply (a direct-connection identity has no exit geography to align).

Inputs: name (required), live.

profile_createA

Create a new identity. Its fingerprint is generated and frozen on the spot.

You do not choose the fingerprint — the point of the product is that every identity gets one self-consistent, frozen set of traits that stays byte-identical across restarts. Do not create identities speculatively: they count against the installation's quota.

Args: name: the new identity's name. Must be unique — creating a name that already exists fails rather than overwriting it. engine: which browser core backs the identity. Leave unset to use this installation's default; an unknown value is rejected with the list of accepted ones. The engine field in profiles_list shows what existing identities use. proxy: exit proxy URL, e.g. "http://user:pass@host:port" or "socks5://host:port" — any vendor, bring your own. Omit it and the identity runs on a direct connection. Test a URL with proxy_check before binding it here. group, tags, note: the local ledger — which account, email, or purpose this identity is bound to. Free text, searchable in the app, and returned under meta by profiles_list. urls: startup tabs — pages opened automatically when the identity starts. force_dark: personal display preference, OFF by default. True inverts web pages that have no dark theme of their own (Google Ads and the like) to dark; sites may notice the changed colors, so use it only on identities the user manages for themselves, never on accounts being built up. Leave unset to keep pages exactly as the sites render them. Chrome-engine identities only. os: which operating system the identity presents as: "windows", "macos", "linux", "android" or "ios". Leave unset for this computer's own OS. "android" and "ios" are phone identities: Chrome engine only, and they need a recent Chrome kernel (an older one is rejected with os_needs_kernel). "ios" is simulated: it sets the browser identity, screen and touch to match an iPhone, suited to mobile web pages. mobile_model: the phone model for an "android" / "ios" identity, as an id. If you leave it unset and the OS has no default model yet, the call is rejected with mobile_model_required and the message lists the accepted ids — pick one and call again. Ignored for desktop OSes (passing it there is rejected).

Returns {name, os, created}. Fails with a readable message if the name is taken (409), if the quota is reached or the installation is unauthorized (403), or if an argument is rejected (422).

Inputs: name (required), os, note, tags, +6 more.

profile_deleteA

Move an identity to the recycle bin. Recoverable — this is not erasure.

The identity's browser storage, cookies and logged-in sessions go to the recycle bin intact and profile_restore brings them back unchanged. It stops counting against the installation's quota while it sits there, and it no longer appears in profiles_list.

A running identity is refused (409) rather than killed under itself — stop it with profile_stop first, then delete. Deleting a name that is already in the recycle bin replaces the older copy, so the older one is lost.

There is deliberately NO tool here for permanent deletion. Emptying the recycle bin destroys logged-in accounts with no way back, so it is a manual action in the desktop app only — a person does it, looking at what they are about to lose. Do not look for a way around this; tell the human instead.

Args: name: identity name, exactly as profiles_list reports it.

Fails with a readable message if the identity does not exist (404), or if it is still running (409).

Inputs: name (required).

profile_restoreA

Bring an identity back from the recycle bin, exactly as it was.

Its frozen fingerprint, proxy binding, cookies and login state all come back — restoring is not re-creating, so nothing is regenerated and no logged-in account is lost.

Args: name: the trashed identity's name.

Returns {name, engine, created}. Fails with a readable message if nothing by that name is in the recycle bin (404), or if a live identity has taken the name since (409) — rename or delete that one first, then restore.

Inputs: name (required).

profile_settingsA

Change a display setting of an existing identity. Only the settings you pass are changed; everything else in its launch settings stays as it is.

Args: name: identity name, exactly as profiles_list reports it. force_dark: True = force dark web pages (inverts sites that have no dark theme; the identity's color scheme then reads as dark too). False = off, pages render exactly as the sites intend (the default). Sites may notice forced dark colors — reserve it for identities the user manages for themselves. Chrome-engine identities only. Takes effect the next time the identity starts.

Returns {name, launch} with the launch settings now stored.

Inputs: name (required), force_dark.

profiles_listA

List every identity in this installation, with its live status.

Each entry carries: name, os, engine (which browser core backs it), created, proxy (the exit server only — never credentials), status ("running" when a browser is open for it, otherwise "idle"), and meta (the local ledger: group, tags, note, last_launched).

Call this first to find the exact name to pass to profile_start / profile_stop; names are case-sensitive.

Inputs: no named parameters. Returns: result

profile_startA

Open a browser session for an identity and return the endpoint to drive it.

The identity keeps its frozen fingerprint, its exit proxy, and its logged-in cookies — starting it does not re-randomize anything. Starting an identity that already has a session open is a no-op that returns the existing one.

Args: name: identity name, exactly as profiles_list reports it. headless: run without a visible window. Default False (headed), which is what sites expect and what you want for anything login-shaped.

Returns the session record: name, opened_at, idle_seconds, url (the page it is on), plus cdp_endpoint — a ws:// DevTools address you can attach your own automation to. It is only published for Chrome-core identities that have external debugging turned on in the app (off by default; Edit -> Advanced -> External debugging, needs a second verification, then reopen the identity). Otherwise it is None, cdp_unavailable gives the daemon's reason code (external_debug_off, external_debug_not_granted, not_supported_for_engine, starting) and cdp_note says what to do — the session commands work either way.

Prefer the daemon's own commands over attaching to cdp_endpoint. A session driven from outside bypasses Nullprint's consistency guards, so an outside tool can set a viewport, locale, timezone, or header that contradicts the identity's frozen fingerprint and make it detectable. Attach at your own risk, and change nothing the identity did not already claim.

Fails with a readable message if the identity does not exist (404), if too many sessions are already warm (429), or if the daemon is not running.

Inputs: name (required), headless.

profile_stopA

Stop an identity's browser, however it was started.

Cookies and login state live in the identity's own storage and survive the stop; whatever was typed into an open form does not. Stop identities you are done with — a running identity holds a warm browser and keeps its login state exposed.

Two things can be running for one identity and this closes either: the warm session profile_start opens (the daemon drives it), and a window the desktop app launched on its own. The session is closed first; if there is none, the identity-level stop is used instead, which also terminates a launched window and is a no-op on an identity that is already idle.

Args: name: identity name, exactly as profiles_list reports it.

Returns {name, stopped, closed}: stopped is False when the identity was already idle, and closed lists what was actually shut down.

Fails with a readable message if the identity does not exist, or if the daemon is not running.

Inputs: name (required).

proxy_checkA

Test a proxy URL and report where it actually comes out. No identity needed.

Use it before binding a proxy to an identity with profile_create: a dead or slow exit found here costs nothing, the same exit found halfway through a signup costs the account.

Args: url: the proxy URL to test, e.g. "http://user:pass@host:port" or "socks5://host:port".

Returns {ok: true, exit_ip, country, latency_ms} when the proxy works, or {ok: false, error} when it does not. A dead proxy is an ANSWER, not a failure — check the ok field rather than assuming success. Note that country can be null even on a working proxy if the exit IP cannot be geolocated.

This tests a bare URL. To test the proxy an identity is already bound to, the daemon's per-identity check is a separate endpoint not yet exposed here.

Inputs: url (required).

session_click_selectorA

Click an element on the session's current page, located by a CSS selector.

Requires a session opened with profile_start first. selector is a CSS selector (e.g. "button#submit", "a.nav-link") — not an XPath, not a role/name pair (use session_snapshot to find one).

Args: name: identity name, exactly as profiles_list reports it. selector: CSS selector for the element to click. nth: optional, 0-based — which element to use when the selector matches several. Leave it out and a selector that matches several elements fails with "matched N elements"; then write a more specific selector or pass nth.

Returns {ok: true}. Fails with a readable message if the session is not open (409 — call profile_start first), the identity does not exist (404), the selector matches several elements and no nth was given, or the selector never matches / the click times out (502).

Inputs: name (required), selector (required), nth.

session_dialogA

Answer the JavaScript dialog (alert, confirm, prompt, beforeunload) open on the session's page.

Dialogs are left open, as in a normal browser: while one is open the page is blocked and the other session_* tools fail with 409 "a JavaScript is open on the page ()". Call this to answer it, then retry. A beforeunload that your own session_goto (or click) causes is accepted automatically and never shows up here.

Args: name: identity name, exactly as profiles_list reports it. action: "accept" (OK / Leave) or "dismiss" (Cancel / Stay). prompt_text: for a prompt() dialog, the text to enter before accepting; omit it to accept the prompt's default value.

Returns {ok, action, type, message} for the dialog that was answered. Fails with a readable message if no dialog is open (409), the session is not open (409 — call profile_start first) or the identity does not exist (404).

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

session_evalA

Evaluate a JavaScript expression on the session's current page.

Requires a session opened with profile_start first. A page-JS error is data to read, not a tool failure: the daemon returns {"ok": false, "error", "error_type"} instead of raising when the expression throws.

Args: name: identity name, exactly as profiles_list reports it. expr: the JavaScript expression to evaluate in the page, e.g. "document.title" or "document.querySelectorAll('a').length".

Returns the {ok, result} envelope: {"ok": true, "result": } on success. result is whatever the expression evaluates to as JSON — string, number, boolean, object, array, or null — not necessarily a string; do not assume its type. Fails with a readable message (raises, rather than the {ok: false} envelope above) if the session is not open (409 — call profile_start first) or the identity does not exist (404).

Inputs: expr (required), name (required).

session_fill_selectorA

Fill a text field on the session's current page, located by a CSS selector.

Uses Playwright's fill(), which drives React/Vue-controlled inputs correctly (setting the DOM value directly does not). Requires a session opened with profile_start first. selector is a CSS selector, not an XPath.

Args: name: identity name, exactly as profiles_list reports it. selector: CSS selector for the input to fill. text: the text to put in the field, replacing whatever was there. nth: optional, 0-based — which element to use when the selector matches several (see session_click_selector).

Returns {ok: true}. Fails with a readable message if the session is not open (409 — call profile_start first), the identity does not exist (404), the selector matches several elements and no nth was given, or the selector never matches / the fill times out (502).

Inputs: name (required), text (required), selector (required), nth.

session_gotoA

Navigate a session's current page to a URL.

Open the identity's session with profile_start first — this drives an already-open session, it does not open one itself.

Args: name: identity name, exactly as profiles_list reports it. url: the URL to navigate to, e.g. "https://example.com/login".

Returns {url}: the page's URL after navigation. Fails with a readable message if the session is not open (409 — call profile_start first) or the identity does not exist (404).

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

session_pressA

Press a keyboard key on the session's current page (whatever is focused).

Requires a session opened with profile_start first. Use Playwright key names, e.g. "Enter", "Tab", "Escape", "Control+A".

Args: name: identity name, exactly as profiles_list reports it. key: the key (or chord) to press.

Returns {ok: true}. Fails with a readable message if the session is not open (409 — call profile_start first) or the identity does not exist (404).

Inputs: key (required), name (required).

session_screenshotA

Take a screenshot of the session's current page and return it as an image.

Use it when you need to SEE the page (layout, images, a captcha, whether something rendered); session_snapshot is cheaper for reading text and finding selectors. Requires a session opened with profile_start first. The image comes back inline — nothing is written to disk.

Size is capped so it does not flood your context: at most 2000 px on the longest side, in CSS pixels. A full page bigger than that falls back to the visible viewport (scroll with session_eval, e.g. "window.scrollBy(0, innerHeight)", and take another); a PNG over 1 MB is re-taken as JPEG. What happened is said in the returned info.

Args: name: identity name, exactly as profiles_list reports it. full_page: true for the whole scrollable page, false (default) for what is visible in the window.

Returns the image, then {format, width, height, full_page, bytes, note?}. Fails with a readable message if the session is not open (409 — call profile_start first), the identity does not exist (404), or the visible window itself is over 2000 px (needs Nullprint 0.2.31+ on high-DPI displays; otherwise make the window smaller).

Inputs: name (required), full_page.

session_snapshotA

Take an accessibility-tree snapshot of the session's current page.

This is the primary way to see what is on a page before acting on it — read it to find the roles/names/selectors to pass to session_click_selector or session_fill_selector. Requires a session opened with profile_start first.

Args: name: identity name, exactly as profiles_list reports it.

Returns {snapshot}: the page's accessibility tree as text. Fails with a readable message if the session is not open (409 — call profile_start first) or the identity does not exist (404).

Inputs: name (required).

session_switch_tabA

Bring one of the session's open tabs to the front and make it the active one.

Requires a session opened with profile_start first. Get index from session_tabs — indices are only valid as of that snapshot, a tab opened or closed since shifts them.

Args: name: identity name, exactly as profiles_list reports it. index: the tab's index, from session_tabs.

Returns {index, url} for the now-active tab. Fails with a readable message if the session is not open (409 — call profile_start first), the identity does not exist (404), or the index is out of range (422).

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

session_tabsA

List the session's open tabs, with the currently active one marked.

Requires a session opened with profile_start first. Use this to find the index to pass to session_switch_tab.

Args: name: identity name, exactly as profiles_list reports it.

Returns {tabs, active}: tabs is a list of {index, url}, active is the index of the tab currently in front. Fails with a readable message if the session is not open (409 — call profile_start first) or the identity does not exist (404).

Inputs: name (required).

trash_listA

List the identities in the recycle bin — what is still recoverable.

Read-only. This is how you find out what can be restored: deleted identities do not appear in profiles_list, so without this you could only restore a name you already knew. Pair it with profile_restore.

Each entry carries name, engine, os, created, and deleted_at. Newest deletion first. An empty list means the recycle bin is empty.

Nothing here is gone yet — everything listed still has its cookies and login state and comes back intact via profile_restore.

Inputs: no named parameters. Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 20 tools

    Disambiguation4/5

    Tools split into two clearly labelled families (profile_* for identity lifecycle, session_* for page driving), and the descriptions explicitly contrast the few near-pairs (session_snapshot vs session_screenshot, profile_stop vs profile_delete). The main residual overlaps are session_click_selector/session_fill_selector vs session_eval, and session_press versus typing, but each states its own niche. No two tools appear to do the same thing.

    Naming Consistency4/5

    Nearly everything follows a noun_verb or verb-with-prefix pattern (profile_start, session_goto, proxy_check, trash_list), so the family is obvious from the name. Minor deviations: profiles_list is plural where the rest are singular nouns, and session_snapshot/session_screenshot are noun-only rather than verb-bearing. Still highly predictable.

    Tool Count4/5

    20 tools is at the upper edge but each maps to a genuine operation: 9 identity/quota/proxy tools plus 10 page-driving tools plus trash_list. There is little padding, though a couple of session primitives (press, eval) could arguably be folded into a broader interaction tool. Slightly heavy rather than excessive.

    Completeness3/5

    Core identity lifecycle (create/list/start/stop/settings/checkup/delete/restore/trash) and core navigation/read/act primitives are covered, but there are notable gaps: no way to open or close a tab (only list and switch), no select/hover/upload/wait operations, no cookie or storage inspection, and profile_settings only exposes force_dark despite profile_create accepting group/tags/note/proxy/os. Agents will hit dead ends on tab management and metadata editing.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables Claude Code to control a real browser using AI for web scraping, competitive intelligence, and UX auditing through the MCP protocol.
      -
    • A
      license
      A
      quality
      B
      maintenance
      Enables assistants such as Claude Code, Codex, and Gemini CLI to drive a real browser over MCP — navigating, clicking, typing, and reading live pages from plain-English instructions. Supports optional proxy routing, persistent profiles for surviving logins, and reproducible browser identities via seeds.
      16
      16
      32,560
      MIT
    • F
      license
      Not graded
      quality
      A
      maintenance
      Exposes a localhost MCP endpoint that lets AI agents drive isolated browser profiles — navigating, clicking, typing, extracting, screenshotting, evaluating JS, and managing tabs and cookies — so real authenticated workflows can be completed from MCP clients like Cursor or Claude Desktop. Cookies, login state, fingerprints, and proxies persist per profile across launches and AI sessions.
      -