nullprint-mcp
OfficialManage and drive Nullprint antidetect browser identities through MCP—create/list/start/stop/delete/restore profiles, check fingerprints/proxies, and automate pages in open sessions.
List profiles with status, engine, proxy, and ledger metadata; create profiles with proxy, startup URLs, group/tags/note, OS/mobile model, and force_dark.
Start and stop browser sessions, optionally headless, and return a CDP endpoint when enabled.
Change display settings such as force_dark; run consistency checkups in stored or live mode; test a proxy’s exit IP, country, and latency.
Soft-delete profiles to the recycle bin, list recoverable profiles, and restore them intact.
Drive open sessions: navigate pages, take accessibility snapshots, click/fill by CSS selector, press keys, evaluate JavaScript, list/switch tabs, and answer JavaScript dialogs.
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-mcpClaude 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:
--daemon-url/--portNULLPRINT_DAEMON_URLNULLPRINT_PORT~/.nullprint/daemon.json(NULLPRINT_HOMEchanges 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 |
| List every profile with status (running / idle), exit and ledger metadata |
|
| Open a browser session for a profile; returns the driving endpoints |
|
| Stop that profile's browser (session or app-launched window) |
|
| Create a profile (fingerprint generated and frozen), optionally with proxy, ledger and start pages |
|
| Change a display setting of an existing profile — today |
|
| Consistency check-up, returns |
|
| Stateless proxy test: exit IP, country, latency |
|
| Soft delete to the recycle bin (recoverable); refused while running |
|
| Read-only list of recoverable profiles in the recycle bin |
|
| Restore from the recycle bin with fingerprint, proxy and logins intact |
|
| Navigate the session's current page |
|
| Accessibility tree of the current page (find selectors, read state) |
|
| Screenshot of the current page as an image ( |
|
| Click an element by CSS selector ( |
|
| Fill an input by CSS selector ( |
|
| Send a key (e.g. |
|
| Run JavaScript on the page, returns |
|
| List the session's tabs and the active one |
|
| Bring a tab to the front |
|
| Answer the JavaScript dialog (alert / confirm / prompt / beforeunload) open on the page: |
|
Notes that matter when writing prompts:
session_*tools need an open session. They drive the warm session opened byprofile_start; calling them on a profile without one returns 409. Selectors are CSS, not XPath or role/name; callsession_snapshotfirst when you do not know a selector.Selectors must match one element. If a selector matches several,
session_click_selector/session_fill_selectorfail with "matched N elements"; write a more specific selector or passnth(0-based).session_screenshotis 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. Usesession_snapshotto 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 withsession_dialog, then retry. A beforeunload caused by your ownsession_gotoor click is accepted automatically.session_evalreturns an envelope. A page-side JavaScript error comes back as data ({ok: false, error, error_type}), not as a tool failure;resultfollows the expression's type.profile_stophas 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_createdoes not hard-code a kernel. Leaveengineempty to use the app's default; unknown values come back as a 422 listing the options.proxy_checkfailures are data. An unreachable proxy returns{ok: false, error}; only an unreachable daemon raises.profile_startreturnscdp_endpoint(aws://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 isnull, withcdp_unavailable(reason code) andcdp_notesaying 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 thesession_*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 --helpTools 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 CodexClaude 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 toolsprofile_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
Scored across 20 tools
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.
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.
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.
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
Related MCP Connectors
Connect ChatGPT and Claude to your Mac, Windows or Linux with secure MCP remote access.
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Browz hosted MCP (free public beta): let an AI app drive your own Browz browser profiles from anywhere. Connect https://mcp.gobrowz.com/mcp and sign in with your Browz account (OAuth) or an agent token. Each call is relayed to the Browz app on your computer, which must be online with Remote control on and have a hardware security chip (Mac Secure Enclave or TPM 2.0). 17 tools: profiles, tabs, navigate, snapshot, act, wait, screenshot. Cookies, downloads and stored sign-ins stay on your computer.
Related MCP Servers
- AlicenseAqualityBmaintenanceMCP server + Chrome extension that gives AI coding agents control of your real browser with existing sessions, logins, and cookies. Works with Cursor, Claude, Windsurf.24154 npm59MIT
- FlicenseNot gradedqualityBmaintenanceEnables Claude Code to control a real browser using AI for web scraping, competitive intelligence, and UX auditing through the MCP protocol.-
- AlicenseAqualityBmaintenanceEnables 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.161632,560MIT
- FlicenseNot gradedqualityAmaintenanceExposes 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.-