# Browz

> Browz is an anti-detect browser for people and AI agents. For AI agents, you decide exactly what each agent may do: its own key, its own profiles, only the sites you allow, sign-ins it can use on your computer but never read, and a person for the login. Underneath, every profile’s fingerprint is set in the browser engine itself, not by a script on top, and you can test it yourself at https://gobrowz.com/tools/browser-fingerprint-test (how: https://gobrowz.com/engine-level-fingerprint-protection). Each profile is an isolated browser with its own consistent fingerprint, proxy, cookies and storage, so what one profile does stays apart from every other. AI agents drive the same profiles through MCP, a local REST API, a CLI, SDKs or the Chrome DevTools Protocol.

Browz runs on your computer (macOS, Windows, Linux). The browser an agent drives is the real profile on that computer. Install the app from the download page and open it; everything below talks to it. Install Browz, open it, and your agent can start: no account needed for local use. Keep the app open while your agent works; it can stay on its sign-in screen. Signed out, an agent can create profiles, start them and drive them through the local MCP server, the Local API, the CLI or CDP, with local agent keys and stored sign-ins. A Browz account adds sync across your computers, teams, Remote control with the hosted MCP server for agents that run in the cloud, and agent tokens for them.

How an agent connects:

- **MCP, local:** `npx -y @browz/mcp` starts the MCP server that ships in Browz (stdio). For Claude Code: `claude mcp add browz -- npx -y @browz/mcp`. Or point the client at the binary, `/Applications/Browz.app/Contents/Resources/browz-mcp` on macOS. It reads the app's own credentials, so there is no token to paste. `npx -y @browz/mcp --http` serves Streamable HTTP on loopback (`http://127.0.0.1:50334/mcp`). With Python's uv instead of Node: `uvx browz-mcp` (the `browz-mcp` package on PyPI; `pipx run browz-mcp` also works), or `{ "command": "uvx", "args": ["browz-mcp"] }` in a client's config.
- **MCP, remote (beta):** cloud agents use `https://mcp.gobrowz.com/mcp`, which relays to a computer with Remote control turned on in Browz. Clients sign in with OAuth 2.1, or send a Browz agent token as a bearer token. It is a free public beta. It needs the Browz app open on your computer with Remote control turned on (Settings › Account), on a computer with a hardware security chip: a Mac with a Secure Enclave (every Apple silicon Mac, and Intel Macs with a T2 chip), or TPM 2.0 on Windows or Linux. Run it on the computer itself, not inside a Docker container or a virtual machine, which usually has no security chip of its own. While the hosted MCP is in beta, every account, Free included, gets the free beta allowance for hosted agents: 2 hosted sessions at once, 2,000 actions and 300 relay minutes a month, and 30 tool calls a minute and 2,000 in any 24 hours for each connected agent. The monthly counts reset at 00:00 UTC on the 1st. A paid plan keeps its own hosted allowance, and Pro 50 and above include more. Agents on your own computer, through the local MCP server, are never counted. It offers 17 tools: your computers, profiles, tabs, pages (navigate, snapshot, act, wait and screenshot), hand-off to a person, and ending a session. Cookies, running script, downloads and stored sign-ins stay with the local MCP server on your computer, by design. For hosted use, page snapshots, screenshots and the text an agent types pass through our server encrypted. They become unreadable after 7 days and are then deleted. The action log (the tool, the profile, the page’s origin and path, the outcome and the time, without page content) is kept for 90 days. Setup: https://gobrowz.com/docs/ai-agents#remote.
- **Local REST API:** `http://127.0.0.1:50333`, loopback only. Send `Authorization: Bearer <token>`, with the token from `<data dir>/api-token` (`~/.browz/api-token` by default). Create a profile with `POST /api/v1/profile/create`, start it with `POST /api/v1/browser/start`.
- **CDP:** the start call returns `cdpEndpoint`; attach Playwright (`chromium.connectOverCDP`), Puppeteer (`puppeteer.connect({ browserURL })`) to it, or give Selenium `debuggerAddress: 127.0.0.1:<debugPort>`. Never ask the library to launch its own Chrome.
- **CLI:** the `browz` command is built into the agent (`/Applications/Browz.app/Contents/Resources/browz-agent` on macOS): `browz list`, `browz start <name>`, `browz --json list`.
- **TypeScript SDK:** `npm install @browz/sdk`, then `new Browz({ token })`, `profiles.create()`, `browser.start(id)`.
- **Python SDK:** `from browz import Browz`, standard library only. It is in the `browz-mcp` package on PyPI.

How an agent connects safely:

- **Its own key:** the owner gives each agent a local agent key (`blcl_…`) instead of the Local API token: `browz agent-token create --name "shop checker" --profiles own --sites shop.example.com` prints it once. The key is limited to its scopes (`browz:browser:advanced` for script, cookies and downloads and `browz:credentials:use` for stored sign-ins are never in the default set), its profiles and its allowed sites, and to 60 calls a minute and 10,000 a day by default. The owner can revoke it, or stop every agent at once (`browz agent-token stop-all`). Every call is logged on that computer for 90 days: tool, profile, page origin and path (never the query or page content), result. Free on every plan, enforced on that computer without the account server; managed in the app (Automate › Agent keys and Saved sign-ins) or from the command line (`browz agent-token`, `browz credential`). Give it to `browz-mcp` over stdio as `BROWZ_LOCAL_AGENT_TOKEN` (or `BROWZ_LOCAL_AGENT_TOKEN_FILE`), to `--http` and `serve` as the bearer, and to the Local API and SDKs as `Authorization: Bearer blcl_…` or `BROWZ_TOKEN`.
- **Stored sign-ins:** the owner stores a site's username, password and TOTP seed with `browz credential add` (secrets from a hidden prompt, never argv). The agent calls `browz_credential_list` (labels, masked usernames, sites; never a secret), then `browz_credential_fill` with a field ref from `browz_snapshot`; Browz types the value itself, only on the credential's sites over https, a password only into a real password field, and returns only `filled: true`. Until the page changes, `browz_evaluate`, `browz_screenshot` and text waits are refused on that profile and snapshots redact the value; every fill is in the local action log without the value. Store sign-ins only for sites you trust with them, since a page that copies a password can expose it, and run an untrusted agent under another OS user, since a program running as the same user can read Browz's data folder. Stored sign-ins work through the local MCP server and the Local API. They are for accounts the person is entitled to use.

An agent's loop: `browz_profile_create` and `browz_profile_start`, or `browz_session_open` (every page tool takes the profile id, its `profileId`, as `id`), `browz_navigate`, `browz_snapshot` (an accessibility tree with element refs), `browz_act` (real input on a ref), `browz_wait`, `browz_screenshot`, then `browz_session_end` or `browz_session_close`. When a page needs a sign-in, a 2FA code or a CAPTCHA, call `browz_request_human` and let the person at the computer finish it, or, for a sign-in the person stored, use `browz_credential_fill`.

Acceptable use: use agents only where the site's terms and the law allow it. A person completes CAPTCHAs; Browz never solves them. Our Acceptable Use Policy applies to agents the same way it applies to people.

## Docs

- [Browz for AI agents](https://gobrowz.com/ai-agents): why an agent needs its own isolated browser, and what Browz offers it
- [Agent setup](https://gobrowz.com/docs/ai-agents): step-by-step setup for Claude, OpenAI, Grok, Gemini, Cursor, VS Code and agent frameworks
- [Developers](https://gobrowz.com/developers): the Local API in five minutes: token, create and start a profile, CDP, CLI, MCP
- [Automation basics](https://gobrowz.com/help/automation-basics): help article on scripting Browz profiles
- [Give an AI agent its own key](https://gobrowz.com/help/agent-keys): help article: create, limit, audit and revoke a local agent key
- [Let an agent sign in without seeing the password](https://gobrowz.com/help/agent-stored-sign-ins): help article: store a sign-in and let an agent fill it without seeing it
- [AI agent login without sharing the password](https://gobrowz.com/ai-agent-login-without-sharing-password): why a password in a prompt, env var or agent context leaks, and how an agent signs in with a stored sign-in it never sees: commands, MCP and Local API examples, limits and the security model
- [Full agent docs](https://gobrowz.com/llms-full.txt): this file plus the MCP, sessions, safety (with local agent keys), headless, human-handoff and stored-credentials docs in one text file

## Integration guides

- [All integrations](https://gobrowz.com/integrations/): setup guides for AI agent clients, automation libraries and proxy setups
- [AI agent clients](https://gobrowz.com/integrations/ai-agents/): the Browz MCP server in each agent client and framework, with its exact config
- [Claude Code](https://gobrowz.com/integrations/ai-agents/claude-code): One command adds Browz to Claude Code, for you or for the whole project.
- [Claude Desktop](https://gobrowz.com/integrations/ai-agents/claude-desktop): A double-click extension, or one entry in claude_desktop_config.json.
- [VS Code (Copilot agent mode)](https://gobrowz.com/integrations/ai-agents/vscode): One code --add-mcp command, or an entry in the workspace MCP config.
- [Gemini CLI](https://gobrowz.com/integrations/ai-agents/gemini-cli): gemini mcp add, or one entry in ~/.gemini/settings.json.
- [Windsurf (Cascade)](https://gobrowz.com/integrations/ai-agents/windsurf): One mcpServers entry in Cascade’s MCP config file.
- [Zed](https://gobrowz.com/integrations/ai-agents/zed): A context_servers entry in Zed’s settings.json.
- [Cline](https://gobrowz.com/integrations/ai-agents/cline): An entry in cline_mcp_settings.json, with tool approval kept on.
- [Goose](https://gobrowz.com/integrations/ai-agents/goose): A stdio extension, added with goose configure or in config.yaml.
- [Codex CLI](https://gobrowz.com/integrations/ai-agents/codex-cli): codex mcp add, or an [mcp_servers.browz] table in config.toml.
- [LangChain](https://gobrowz.com/integrations/ai-agents/langchain): langchain-mcp-adapters loads the Browz tools into a LangChain agent.
- [LangGraph](https://gobrowz.com/integrations/ai-agents/langgraph): A LangGraph agent with the Browz tools, in one MCP session per run.
- [CrewAI](https://gobrowz.com/integrations/ai-agents/crewai): Hand the Browz MCP tools to a CrewAI agent with one adapter.
- [AutoGen](https://gobrowz.com/integrations/ai-agents/autogen): McpWorkbench hands the Browz tools to an AutoGen AssistantAgent.
- [n8n](https://gobrowz.com/integrations/ai-agents/n8n): The MCP Client Tool node, over HTTP to a local Browz server.
- [Automation libraries](https://gobrowz.com/integrations/automation/): attach a library to a Browz profile over CDP, or drive it through the local API and CLI
- [Playwright](https://gobrowz.com/integrations/automation/playwright): connectOverCDP to a Browz profile: its own cookies, fingerprint and proxy.
- [Playwright for Python](https://gobrowz.com/integrations/automation/playwright-python): connect_over_cdp from Python, with a profile that keeps its sign-in.
- [Puppeteer](https://gobrowz.com/integrations/automation/puppeteer): puppeteer.connect to a running profile; disconnect, never close.
- [Selenium](https://gobrowz.com/integrations/automation/selenium): ChromeDriver attaches with debuggerAddress; match its major version.
- [browser-use](https://gobrowz.com/integrations/automation/browser-use): Hand browser-use a Browz profile’s CDP URL instead of its own browser.
- [Stagehand](https://gobrowz.com/integrations/automation/stagehand): Stagehand 3 attaches to a Browz profile with cdpUrl.
- [Raw CDP](https://gobrowz.com/integrations/automation/raw-cdp): Plain WebSocket and fetch to a profile’s DevTools endpoint, no library.
- [Local REST API](https://gobrowz.com/integrations/automation/rest-api): Create, start, navigate, screenshot and stop profiles with curl.
- [browz CLI](https://gobrowz.com/integrations/automation/cli): Create, start and stop profiles from a shell script.
- [Proxy setups](https://gobrowz.com/integrations/proxies/): residential, mobile, datacenter, SOCKS5, HTTP and HTTPS proxies, rotating vs sticky, proxies for agent sessions, DNS and WebRTC

## Machine-readable

- [Local API OpenAPI spec (JSON)](https://gobrowz.com/openapi/local-api.json): OpenAPI 3.1 description of every Local API route, with full schemas for profiles, browser control, proxies, cookies, tokens and agent sessions
- [Local API OpenAPI spec (YAML)](https://gobrowz.com/openapi/local-api.yaml): the same spec as YAML
- [MCP tool list](https://gobrowz.com/mcp/tools.json): every MCP tool with its description, input schema, hints, and whether the local or remote server offers it
- [Claude Desktop extension](https://gobrowz.com/agents/browz.mcpb): one-click install of the bundled MCP server in Claude Desktop
- [One-line installer](https://gobrowz.com/agents/install.sh): puts the bundled MCP server on your PATH and adds it to a client (macOS, Linux)

## Hosted account

- [Remote MCP server (beta)](https://mcp.gobrowz.com/mcp): Streamable HTTP MCP for cloud agents; OAuth 2.1 with dynamic client registration and PKCE, discovered from its protected resource metadata; a free public beta
- [Hosted agent setup (beta)](https://gobrowz.com/docs/ai-agents#remote): what the hosted server needs (the Browz app open with Remote control on, a hardware security chip), its beta limits, its tools and what passes through our server
- [Agent tokens](https://gobrowz.com/docs/ai-agents#tokens): create a scoped token (up to 90 days) for clients that authenticate with a bearer token; keep it in BROWZ_AGENT_TOKEN

## Product

- [Download](https://gobrowz.com/download): Browz for Mac, Windows and Linux, with requirements
- [Pricing](https://gobrowz.com/pricing): plans and what each includes
- [Security](https://gobrowz.com/security): how profiles, sessions and proxy credentials are protected: they stay on your computer and sync end-to-end encrypted
- [Agent benchmark](https://gobrowz.com/agent-benchmark): the same AI agent on public web tasks through the Browz MCP server and through a plain browser MCP
- [Browser fingerprint test](https://gobrowz.com/tools/browser-fingerprint-test): free tool: what a browser reveals to websites and whether its values are consistent; runs in the browser, sends nothing
- [Engine-level vs injected-script fingerprint protection](https://gobrowz.com/engine-level-fingerprint-protection): what a website can observe when fingerprint values are overridden by a script, compared with values produced by the browser engine, and how to test any browser
- [Best anti-detect browsers for AI agents (2026)](https://gobrowz.com/best-anti-detect-browsers-for-ai-agents): a buyer's guide written by Browz: ten browsers for AI agents scored on thirteen published checkpoints, every cell sourced from the vendor's public pages and dated

## Blog

- [Blog](https://gobrowz.com/blog/): explainers and guides on fingerprinting, AI agents, proxies, multi-account work and security; Atom feed at /blog/feed.xml
- [Browser profiles for privacy: keep work, personal and research browsing apart](https://gobrowz.com/blog/browser-profiles-for-privacy): How sites link your work, personal and research browsing, why private windows only go part way, and a step-by-step plan for one browser profile per role
- [Canvas fingerprinting explained: why random noise gives a browser away](https://gobrowz.com/blog/canvas-fingerprinting-explained): How a canvas fingerprint is made, why it differs between computers, why blocking or random noise stands out, and how to test your own browser in two minutes
- [Connect a cloud AI agent to a browser on your own computer](https://gobrowz.com/blog/hosted-mcp-cloud-agent-local-browser): How a remote MCP server lets a cloud AI agent, such as Claude.ai or an OpenAI agent, drive a browser profile on your own computer, and how to set it up
- [End-to-end encrypted profile sync: what the server can and cannot read](https://gobrowz.com/blog/end-to-end-encrypted-profile-sync): How end-to-end encrypted browser profile sync works, what a sync server still needs to see, how keys and recovery work, and five questions to ask any provider
- [Fingerprint consistency: why mismatched values give a browser away](https://gobrowz.com/blog/fingerprint-consistency-checks): Why detection systems care more about contradictions than rare values, the eight mismatches they check most, and console snippets to check each one yourself
- [Five AI agent browser recipes you can run today](https://gobrowz.com/blog/ai-agent-browser-recipes): Five complete AI agent browser automation examples: Claude Code over MCP, Playwright over CDP, a scheduled headless job, a human hand-off, and two accounts side by side
- [How to choose an anti-detect browser: 10 checks you can run yourself](https://gobrowz.com/blog/how-to-choose-an-anti-detect-browser): Ten practical checks for choosing an anti-detect browser, from engine-level fingerprints and headless parity to proxies, sync encryption, teams, agents and refunds
- [How to give an AI agent a browser safely](https://gobrowz.com/blog/give-an-ai-agent-a-browser-safely): Give an AI agent its own browser profile, its own limited key, sign-ins it can use but never read, and a person for the login. Step by step with Claude Code
- [How to manage multiple accounts safely, within each site's rules](https://gobrowz.com/blog/manage-multiple-accounts-safely): Run several accounts you are allowed to hold without mixing sessions: check the terms, give each account its own profile and exit, and keep the setup tidy
- [How to test your browser fingerprint, and how to read the results](https://gobrowz.com/blog/how-to-test-your-browser-fingerprint): A step-by-step guide to running a browser fingerprint test, reading every section and consistency check, and comparing two runs to test browser profiles
- [How we benchmark AI agents in a browser: 50 tasks, open harness, raw results](https://gobrowz.com/blog/how-we-benchmark-ai-agents-in-a-browser): The method behind our AI agent browser benchmark: 50 public web tasks, the same agent twice, scoring by program, the results, and how to rerun it yourself
- [How websites recognise automated and headless browsers](https://gobrowz.com/blog/how-websites-recognise-automated-browsers): The signals sites use to spot automated and headless browsers: automation flags, headless differences, fingerprint contradictions, TLS, behaviour and IP reputation
- [Human hand-off for AI agents: let a person finish logins, 2FA and CAPTCHAs](https://gobrowz.com/blog/human-hand-off-for-ai-agents): Human in the loop for browser agents: the agent pauses, you finish the sign-in, 2FA code or CAPTCHA in the same window, and it carries on. How it works
- [Is an anti-detect browser legal? Privacy, site terms and acceptable use](https://gobrowz.com/blog/is-an-anti-detect-browser-legal): Using an anti-detect browser is legal in most places; what decides it is your use. Privacy law, site terms, legitimate uses and how to check a use before you start
- [Managing client accounts as an agency: one browser profile per client](https://gobrowz.com/blog/agency-client-accounts-browser-profiles): A practical setup for agencies running clients' ad, social and marketplace accounts: a profile per account, a folder per client, no shared passwords, clean offboarding
- [Match a profile's timezone, language and location to its proxy](https://gobrowz.com/blog/match-timezone-and-location-to-proxy): Why a timezone or language that disagrees with the proxy's location stands out, how to check all five values in a minute, and how to stay matched when the exit moves
- [Playwright in a real browser profile: attach over CDP, not a fresh browser](https://gobrowz.com/blog/playwright-real-browser-profile-cdp): Run Playwright scripts inside a saved browser profile with its own cookies, fingerprint and proxy: start the profile, then connectOverCDP. Node and Python examples
- [Prompt injection and browser agents: limit what a hijacked agent can reach](https://gobrowz.com/blog/prompt-injection-browser-agents): Prompt injection hides instructions in web pages for an AI agent to follow. Why browser agents raise the stakes, and the controls that cap what a misled agent can do
- [QA testing with browser profiles: see your site as each user and region does](https://gobrowz.com/blog/qa-testing-with-browser-profiles): Test a website as different users, roles and countries with one saved browser profile per test persona, each with its own exit, timezone and languages
- [Residential, datacenter, ISP or mobile proxies: which one a profile needs](https://gobrowz.com/blog/residential-vs-datacenter-vs-mobile-proxies): Datacenter, residential, ISP and mobile proxies compared: how websites see each, sticky or rotating sessions, and which one suits a long-lived browser profile
- [Running several online storefronts where the platform allows it](https://gobrowz.com/blog/run-several-storefronts-separately): How sellers with more than one permitted storefront keep each store's sign-in, staff, market and records apart, with one browser profile and one checked exit per store
- [Share account access with a team without sharing passwords](https://gobrowz.com/blog/share-account-access-with-a-team): Give colleagues access to the accounts they work on without handing out passwords: share signed-in profiles by role and level, one device at a time, with a log
- [TLS fingerprinting (JA3 and JA4) explained for browser users](https://gobrowz.com/blog/tls-fingerprinting-ja3-ja4): How sites fingerprint the TLS handshake and HTTP/2 settings before any page loads, what JA3 and JA4 measure, what changes them, and how to check your own browser
- [Use your own SSH server as a browser profile's proxy](https://gobrowz.com/blog/ssh-server-as-browser-proxy): Turn a server you control into an encrypted exit for a browser profile: how SSH tunnelling works, preparing the server, key sign-in, host-key pinning and checks
- [User agent and client hints: keeping JavaScript and headers in agreement](https://gobrowz.com/blog/user-agent-and-client-hints): How the user agent string, Sec-CH-UA headers and getHighEntropyValues fit together, why changing only one of them gives a browser away, and how to check yours
- [WebGL and WebGPU fingerprinting: what your graphics card gives away](https://gobrowz.com/blog/webgl-webgpu-fingerprinting): What WebGL and WebGPU reveal about your graphics card (names, limits, extensions, rendered images), why a fake renderer contradicts real hardware, and how to check
- [WebRTC leaks: how a page can find your real IP, and how to check a profile](https://gobrowz.com/blog/webrtc-leak-explained): How WebRTC can reveal the address behind a proxy, how to test a browser profile for a WebRTC or DNS leak in two minutes, and the settings that close both
- [What is an anti-detect browser? How it works and who it is for](https://gobrowz.com/blog/what-is-an-anti-detect-browser): An anti-detect browser runs separate profiles, each with its own consistent fingerprint, proxy, cookies and storage. How it works, who uses it and what to check
- [What is an MCP browser? Giving Claude, Cursor and other agents a real browser](https://gobrowz.com/blog/what-is-an-mcp-browser): An MCP browser is a browser an AI agent drives through the Model Context Protocol. What it exposes, local vs remote, and how to set one up in Claude and Cursor
- [What is browser fingerprinting? How websites recognise your browser](https://gobrowz.com/blog/what-is-browser-fingerprinting): Browser fingerprinting identifies a browser from the details it reveals, without cookies. What goes into a fingerprint, why consistency matters and how to test yours

## Policies

- [Acceptable Use Policy](https://gobrowz.com/acceptable-use): what Browz, its automation and AI agents may and may not be used for
- [Terms of Service](https://gobrowz.com/terms): the terms for using Browz
- [Privacy Policy](https://gobrowz.com/privacy): what we store and what never leaves your computer