Browz

Isolated, fingerprint-protected browser profiles for AI agents: one per task, with its own proxy

View on gobrowz.com

Hosted MCP Server

npx add-mcp 'https://mcp.gobrowz.com/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

Before you start

Install Browz and open it. Every setup below drives the profiles of that app, with each profile’s own fingerprint, cookies and proxy.

  • On the computer with Browz, the client starts the MCP server that ships inside the app. It reads the app’s own credentials, so there is nothing to paste. The snippets use the macOS path; elsewhere use %LOCALAPPDATA%\Programs\Browz\browz-mcp.exe (Windows) or /usr/lib/browz/browz-mcp (Linux). In the app, Automate › Connect an AI agent shows the same snippets with the exact path on your computer.
  • Remote clients, including hosted ones, reach your Browz through https://mcp.gobrowz.com/mcp. Most sign in with your Browz account in the browser. Those that cannot use an agent token: see Agent tokens. Beta In free public beta; it needs the Browz app open with Remote control on, on a computer with a hardware security chip. See Hosted agents.

Use agents only where each site’s terms and the law allow it; our acceptable use policy applies to agents the same as to people.

One-line install

On macOS or Linux, with Browz installed, one command puts the MCP server that ships in Browz on your PATH (in ~/.local/bin). Name a client and it adds Browz to that client too: claude-code, claude-desktop, cursor, gemini-cli. Other settings in the client’s config file are kept, the old file is saved next to it, and running it again changes nothing.

curl -fsSL https://gobrowz.com/agents/install.sh | sh
curl -fsSL https://gobrowz.com/agents/install.sh | sh -s -- claude-desktop

It downloads nothing else and needs no token: the server reads the Browz app’s own credentials. Read the script before you run it. On Windows, use Automate › Connect an AI agent in the app.

From npm or PyPI

@browz/mcp on npm

npx -y @browz/mcp setup claude-desktop --write   # or cursor, gemini-cli (Claude Code: claude mcp add)
npx -y @browz/mcp                                  # run the server (stdio)

browz-mcp on PyPI (uvx, pipx)

uvx browz-mcp            # run the server (stdio) with uv
pipx run browz-mcp       # the same with pipx
{ "mcpServers": { "browz": { "command": "uvx", "args": ["browz-mcp"] } } }

Check it works

Ask your agent this. It should answer “Example Domain” and leave no profile behind.

Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.

Hosted agents (remote MCP, beta)

Beta The hosted remote MCP server at mcp.gobrowz.com is in free public beta. Agents that run in the cloud reach the Browz app on your own computer through it: the AI app signs you in with your Browz account, shows what it is asking for, and gets only the access you allow.

What it needs

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.

Connect an agent

  1. In the Browz app, turn on Settings › Account › Remote control. The app keeps one outbound connection to our server; nothing on your computer is opened to the internet. If you turned Remote control on before the hosted server opened, turn it off and on again once.
  2. Add https://mcp.gobrowz.com/mcp to the AI app as a remote MCP server or custom connector. Each client’s section on this page has the exact steps.
  3. The AI app opens a Browz sign-in page. Sign in, check what the app is asking for, choose the workspace and allow it. A client that cannot sign in with a browser uses an agent token instead.

What we have tested

  • The sign-in flow as a new client meets it: discovery from the server’s metadata, client registration, sign-in and consent, the token exchange, refresh and revoke. We also listed and called the tools with the MCP Inspector.
  • Claude Code, end to end, as its section says. Every other client’s remote setup follows that client’s documentation. Tell us how it works for you from the app, under Settings › Help and support.

Tools

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.

The beta allowance

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. When an agent reaches a limit, the tool result says which limit it reached and when it can try again.

What passes through our server

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. See our Privacy Policy.

Stop or revoke an agent

On your account page, under AI agents, you see every connected AI app and agent token with what it did. Limit one to some profiles or to read-only, limit the sites it may open, stop it now, or revoke it. Turning off Remote control in the app cuts every hosted agent off at once.

It is a beta, so the allowance and the tools may change as it grows. Send us feedback from the app, under Settings › Help and support. Use it only where each site’s terms allow it. Our acceptable use policy applies to agents the same as to people.

Claude Code

On the computer with Browz

Add Browz to Claude Code

claude mcp add --transport stdio browz -- /Applications/Browz.app/Contents/Resources/browz-mcp

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

We ran Claude Code end to end against the hosted server, with a token from our sign-in flow in its config (2 November 2026). Signing in from Claude Code’s own /mcp screen should work; tell us if it doesn’t.

Add the remote server; Claude Code signs you in with your Browz account (run /mcp)

claude mcp add --transport http browz https://mcp.gobrowz.com/mcp

Or, without a browser sign-in, use an agent token

claude mcp add --transport http browz https://mcp.gobrowz.com/mcp --header "Authorization: Bearer $BROWZ_AGENT_TOKEN"

Claude Desktop

On the computer with Browz

Or add this to claude_desktop_config.json (Settings › Developer › Edit Config), then restart Claude (macos: ~/Library/Application Support/Claude/claude_desktop_config.json, windows: %APPDATA%\Claude\claude_desktop_config.json, linux: ~/.config/Claude/claude_desktop_config.json)

{
  "mcpServers": {
    "browz": {
      "command": "/Applications/Browz.app/Contents/Resources/browz-mcp",
      "args": []
    }
  }
}

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow Claude Desktop’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Customize › Connectors › Add › Add custom connector, name it Browz, paste this URL and sign in with your Browz account

https://mcp.gobrowz.com/mcp

Claude.ai

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow Claude.ai’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Customize › Connectors › Add › Add custom connector, name it Browz, paste this URL, choose "Sign in now" and sign in with your Browz account

https://mcp.gobrowz.com/mcp

In a chat, turn Browz on under + › Connectors, then ask

Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.

OpenAI (Responses API and Agents SDK)

On the computer with Browz

Agents SDK (Python), running on the computer with Browz

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async def main():
    async with MCPServerStdio(name="browz", params={"command": "/Applications/Browz.app/Contents/Resources/browz-mcp", "args": []}) as browz:
        agent = Agent(name="Browz agent", mcp_servers=[browz])
        result = await Runner.run(agent, "Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.")
        print(result.final_output)

asyncio.run(main())

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow OpenAI (Responses API and Agents SDK)’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Put your Browz agent token in an environment variable (create one on this page)

export BROWZ_AGENT_TOKEN=…   # paste the token you created; never commit it

Responses API (JavaScript): OpenAI calls the Browz remote server for you

import OpenAI from 'openai';

const openai = new OpenAI();
const response = await openai.responses.create({
  model: 'gpt-5',
  tools: [{
    type: 'mcp',
    server_label: 'browz',
    server_url: 'https://mcp.gobrowz.com/mcp',
    authorization: process.env.BROWZ_AGENT_TOKEN,
    require_approval: 'never',
  }],
  input: 'Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.',
});
console.log(response.output_text);

Agents SDK (Python) with the hosted MCP tool

import os
from agents import Agent, HostedMCPTool, Runner

browz = HostedMCPTool(tool_config={
    "type": "mcp", "server_label": "browz", "server_url": "https://mcp.gobrowz.com/mcp",
    "authorization": os.environ["BROWZ_AGENT_TOKEN"], "require_approval": "never",
})
agent = Agent(name="Browz agent", tools=[browz])
print(Runner.run_sync(agent, "Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.").final_output)

xAI Grok

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow xAI Grok’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Put your Browz agent token in an environment variable (create one on this page)

export BROWZ_AGENT_TOKEN=…   # paste the token you created; never commit it

xAI SDK (Python): Grok calls the Browz remote server as a tool

import os
from xai_sdk import Client
from xai_sdk.chat import user
from xai_sdk.tools import mcp

client = Client(api_key=os.environ["XAI_API_KEY"])
chat = client.chat.create(model="grok-4.7", tools=[
    mcp(server_url="https://mcp.gobrowz.com/mcp", server_label="browz", authorization=os.environ["BROWZ_AGENT_TOKEN"]),
])
chat.append(user("Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile."))
print(chat.sample().content)

Or the Responses API over HTTP

curl https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" -H "Content-Type: application/json" \
  -d "$(jq -n --arg t "$BROWZ_AGENT_TOKEN" '{model: "grok-4.7", input: "Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.",
        tools: [{type: "mcp", server_label: "browz", server_url: "https://mcp.gobrowz.com/mcp", authorization: $t}]}')"

Gemini CLI

On the computer with Browz

Add Browz for your user

gemini mcp add --scope user browz /Applications/Browz.app/Contents/Resources/browz-mcp

Or add it to ~/.gemini/settings.json (all: ~/.gemini/settings.json)

{
  "mcpServers": {
    "browz": {
      "command": "/Applications/Browz.app/Contents/Resources/browz-mcp",
      "args": []
    }
  }
}

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow Gemini CLI’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Add the remote server; run /mcp auth browz in Gemini CLI to sign in

gemini mcp add --scope user --transport http browz https://mcp.gobrowz.com/mcp

Or with an agent token

gemini mcp add --scope user --transport http --header "Authorization: Bearer $BROWZ_AGENT_TOKEN" browz https://mcp.gobrowz.com/mcp

Cursor

On the computer with Browz

Or add it to ~/.cursor/mcp.json (all projects) or.cursor/mcp.json (one project) (all: ~/.cursor/mcp.json)

{
  "mcpServers": {
    "browz": {
      "command": "/Applications/Browz.app/Contents/Resources/browz-mcp",
      "args": []
    }
  }
}

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow Cursor’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Or add it to ~/.cursor/mcp.json; Cursor signs you in with your Browz account (all: ~/.cursor/mcp.json)

{
  "mcpServers": {
    "browz": {
      "url": "https://mcp.gobrowz.com/mcp"
    }
  }
}

Or with an agent token from the environment

{
  "mcpServers": {
    "browz": {
      "url": "https://mcp.gobrowz.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:BROWZ_AGENT_TOKEN}"
      }
    }
  }
}

VS Code

On the computer with Browz

Or from a terminal

code --add-mcp '{"name":"browz","type":"stdio","command":"/Applications/Browz.app/Contents/Resources/browz-mcp","args":[]}'

Or in.vscode/mcp.json (one workspace) (all: .vscode/mcp.json)

{
  "servers": {
    "browz": {
      "type": "stdio",
      "command": "/Applications/Browz.app/Contents/Resources/browz-mcp",
      "args": []
    }
  }
}

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow VS Code’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Or in.vscode/mcp.json; VS Code signs you in with your Browz account (all: .vscode/mcp.json)

{
  "servers": {
    "browz": {
      "type": "http",
      "url": "https://mcp.gobrowz.com/mcp"
    }
  }
}

Or with an agent token that VS Code asks for once and keeps in its secret storage

{
  "inputs": [
    {
      "type": "promptString",
      "id": "browz-token",
      "description": "Browz agent token",
      "password": true
    }
  ],
  "servers": {
    "browz": {
      "type": "http",
      "url": "https://mcp.gobrowz.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:browz-token}"
      }
    }
  }
}

browser-use

On the computer with Browz

Install

pip install browser-use   # plus the Browz Python SDK: pip install browz-mcp

Run an agent in a fresh Browz profile (it is deleted afterwards)

import asyncio
from browser_use import Agent, ChatOpenAI
from browz.agents import browz_session, browser_use_browser

async def main():
    with browz_session() as session:
        agent = Agent(task="Open https://example.com and tell me the page title",
                      llm=ChatOpenAI(model="gpt-5"), browser=browser_use_browser(session))
        print((await agent.run()).final_result())

asyncio.run(main())

Stagehand

On the computer with Browz

Install

npm install @browserbasehq/stagehand@3 zod   # plus the Browz TypeScript SDK in sdk/typescript

Drive a fresh Browz profile (it is deleted afterwards)

import { Stagehand } from '@browserbasehq/stagehand';
import { withBrowzSession, stagehandOptions } from '@browz/sdk';

await withBrowzSession(async (session) => {
  const stagehand = new Stagehand(stagehandOptions(session, { model: 'anthropic/claude-haiku-5-5' }));
  await stagehand.init();
  const page = stagehand.context.pages()[0];
  await page.goto('https://example.com');
  console.log(await page.title());
  await stagehand.close();
});

LangChain

On the computer with Browz

Install

pip install langchain-mcp-adapters langgraph "langchain[openai]"

Load the Browz tools into a LangChain agent

import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

async def main():
    client = MultiServerMCPClient({"browz": {"transport": "stdio", "command": "/Applications/Browz.app/Contents/Resources/browz-mcp", "args": []}})
    agent = create_react_agent("openai:gpt-5", await client.get_tools())
    out = await agent.ainvoke({"messages": [("user", "Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.")]})
    print(out["messages"][-1].content)

asyncio.run(main())

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow LangChain’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Put your Browz agent token in an environment variable (create one on this page)

export BROWZ_AGENT_TOKEN=…   # paste the token you created; never commit it

Use the remote server from a hosted agent

import os
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({"browz": {"transport": "http", "url": "https://mcp.gobrowz.com/mcp",
    "headers": {"Authorization": "Bearer " + os.environ["BROWZ_AGENT_TOKEN"]}}})
tools = await client.get_tools()  # inside an async function

LangGraph

On the computer with Browz

Install

pip install langgraph langchain-mcp-adapters langchain-anthropic   # plus the Browz Python SDK: pip install browz-mcp

A LangGraph agent with the Browz tools (one MCP session for the whole run)

import asyncio
from langchain_anthropic import ChatAnthropic
from browz.agents import langchain_tool_session, langgraph_agent

async def main():
    async with langchain_tool_session() as tools:
        agent = langgraph_agent(ChatAnthropic(model="claude-haiku-5-5"), tools)
        out = await agent.ainvoke({"messages": [("user", "Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.")]})
        print(out["messages"][-1].content)

asyncio.run(main())

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow LangGraph’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Put your Browz agent token in an environment variable (create one on this page)

export BROWZ_AGENT_TOKEN=…   # paste the token you created; never commit it

The same agent through the remote server

from browz.agents import langchain_tool_session, langgraph_agent

async with langchain_tool_session(remote=True) as tools:  # inside an async function
    agent = langgraph_agent(model, tools)

OpenAI Agents SDK

On the computer with Browz

Install

pip install openai-agents   # plus the Browz Python SDK: pip install browz-mcp

An agent with the Browz MCP server

import asyncio
from agents import Agent, Runner
from browz.agents import AGENT_PROMPT, openai_agents_mcp_server

async def main():
    async with openai_agents_mcp_server() as browz:
        agent = Agent(name="Browz agent", instructions=AGENT_PROMPT, mcp_servers=[browz])
        result = await Runner.run(agent, "Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.", max_turns=30)
        print(result.final_output)

asyncio.run(main())

JavaScript (@openai/agents)

import { Agent, run } from '@openai/agents';
import { openaiAgentsMcpServer, AGENT_PROMPT } from '@browz/sdk';

const browz = await openaiAgentsMcpServer();
await browz.connect();
try {
  const agent = new Agent({ name: 'Browz agent', instructions: AGENT_PROMPT, mcpServers: [browz] });
  console.log((await run(agent, 'Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.')).finalOutput);
} finally {
  await browz.close();
}

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow OpenAI Agents SDK’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Put your Browz agent token in an environment variable (create one on this page)

export BROWZ_AGENT_TOKEN=…   # paste the token you created; never commit it

Your code connects to the remote server

from browz.agents import openai_agents_mcp_server

async with openai_agents_mcp_server(remote=True) as browz:  # inside an async function
    ...  # Agent(..., mcp_servers=[browz]) as above

Or OpenAI calls it for you (hosted MCP tool)

from agents import Agent
from browz.agents import openai_hosted_mcp_tool

agent = Agent(name="Browz agent", tools=[openai_hosted_mcp_tool()])

CrewAI

On the computer with Browz

Install

pip install 'crewai[anthropic]' 'crewai-tools[mcp]'   # plus the Browz Python SDK: pip install browz-mcp

A crew whose agent uses the Browz tools

from crewai import Agent, Crew, Task
from browz.agents import AGENT_PROMPT, crewai_mcp_adapter

with crewai_mcp_adapter() as tools:
    agent = Agent(role="Browser operator", goal="Do web tasks in Browz browsers",
                  backstory=AGENT_PROMPT, tools=tools, llm="anthropic/claude-haiku-5-5")
    task = Task(description="Using Browz: create a new profile called agent-check, start it, open https://example.com, tell me the page title, take a screenshot, then stop the session and delete the profile.",
                expected_output="The page title", agent=agent)
    print(Crew(agents=[agent], tasks=[task]).kickoff())

Remote, through https://mcp.gobrowz.com/mcp Beta

In free public beta. What it needs, its limits and what passes through our server: Hosted agents.

These steps follow CrewAI’s own documentation. Tell us how they work for you from the app (Settings › Help and support) or the help page.

Put your Browz agent token in an environment variable (create one on this page)

export BROWZ_AGENT_TOKEN=…   # paste the token you created; never commit it

The same crew through the remote server

from browz.agents import crewai_mcp_adapter

with crewai_mcp_adapter(remote=True) as tools:
    ...  # Agent(..., tools=tools) as above

Give each agent its own key

Give every AI agent its own Browz key: limit it to the scopes, profiles and sites it needs, cap how many calls it can make a minute and a day, and revoke it, or stop every agent at once, whenever you want. Every call is logged on your own computer for 90 days, with the page address but not its query, and never the page content. These controls are free on every plan and run entirely on your computer.

A local agent key (blcl_…) is for the MCP server and the Local API on your own computer or server. It is not the same as the agent tokens for the remote server. You manage keys and stored sign-ins in the Browz app, under Automate (Agent keys and Saved sign-ins), or from the command line (browz agent-token and browz credential).

alias browz="/Applications/Browz.app/Contents/Resources/browz-agent"   # macOS; the CLI is built into the agent

# Create a key. It is printed once, on stdout, so capture it; only its hash is kept.
browz agent-token create --name "shop checker" --profiles own --sites shop.example.com > ~/.browz-shop-checker.key
chmod 600 ~/.browz-shop-checker.key

browz agent-token list                          # every key: id, name, scopes, status, last used
browz agent-token log --agent <key id>          # what it did, newest first (90 days)
browz agent-token revoke <key id> --stop-browsers
browz agent-token stop-all                      # suspend every key and stop the browsers they started
browz agent-token resume <key id>               # undo stop-all for one key

By default a key may read and change profiles and drive their browser. --read-only narrows it to reading; --scopes picks exactly what it may do. Running script, cookies and downloads need browz:browser:advanced, and stored sign-ins need browz:credentials:use; neither is in the default set. --profiles own limits it to the profiles it creates, and --sites to pages on those sites and their subdomains. A key lasts 30 days unless you pass --days (up to 90) or --no-expiry, and makes at most 60 calls a minute and 10,000 a day unless you change --per-minute and --per-day. A key can never create or manage keys, or read the log.

Give the key to the agent, never your Local API token:

  • MCP over stdio: set BROWZ_LOCAL_AGENT_TOKEN to the key, or BROWZ_LOCAL_AGENT_TOKEN_FILE to a file that holds it, in the server’s environment. Never pass it as a command-line argument. The server then refuses any tool the key’s scopes do not cover.
  • MCP over HTTP, and browz-mcp serve: the client sends the key as its bearer token.
  • The Local API and the SDKs: send Authorization: Bearer blcl_…, or set BROWZ_TOKEN to the key.
{
  "mcpServers": {
    "browz": {
      "command": "/Applications/Browz.app/Contents/Resources/browz-mcp",
      "env": { "BROWZ_LOCAL_AGENT_TOKEN_FILE": "/Users/you/.browz-shop-checker.key" }
    }
  }
}

On a server without the desktop app, run the same commands as browz-mcp agent-token …. A key governs what an agent does through Browz. Programs that run as the same computer user as Browz can read its data folder, so run an agent you do not trust under another user or in a container.

Sign in without seeing the password

Browz can sign an AI agent in with a password and an authenticator (2FA) code you stored, and the agent never sees either. The agent points at a field, and Browz types the value itself, only on the sites you allowed for that sign-in and only into a real password field (a code may also go into a one-time-code field). Until the page changes, Browz pauses script, screenshots and waiting for page text for the agent in that profile, and every fill is recorded in your local action log without the value. Stored sign-ins are for accounts you are entitled to use.

browz credential add --label "Shop (Jane)" --username [email protected] \
  --site shop.example.com --profile <profile id> --totp
# Password: (hidden prompt)
# TOTP seed (base32 or otpauth:// URI): (hidden prompt)

browz credential list                           # id, label, masked username, scope, 2FA, sites
browz credential update <credential id> --password   # prompts for the new password
browz credential remove <credential id>

# A key reaches stored sign-ins only with this scope, which is never in the default set:
browz agent-token create --name "sign-in bot" --profiles <profile id> --sites shop.example.com \
  --scopes browz:profiles:read,browz:browser,browz:credentials:use
  • Sites. --site says where the sign-in may be typed: a bare domain such as example.com allows it and its subdomains over https; an origin such as https://accounts.example.com allows exactly that. Name the narrowest site that works.
  • Who may use it. One of --profile, --group or --any.
  • Secrets never go on the command line. The password, the TOTP seed and extra secret fields come from a hidden prompt, or from standard input with --password-stdin.
  • What the agent does. It calls browz_credential_list (labels, masked usernames, sites; never a secret), takes a snapshot, then calls browz_credential_fill once per field with the field’s ref. The result says only that the field was filled. A code is worked out by Browz at that moment from the seed.
  • Pace and fields. Each sign-in can be filled 12 times in any 10 minutes. A sign-in page whose code box is a plain text field without autocomplete="one-time-code" is refused; the agent should hand that step to you with browz_request_human.

Store sign-ins only for sites you trust with them: a page that copies or transforms a password it was given can expose it. A key governs what an agent does through Browz. Programs that run as the same computer user as Browz can read its data folder, so run an agent you do not trust under another user or in a container. The protection after a fill lasts while the Browz agent that made it keeps running. Stored sign-ins stay with agents on your computer: hosted agents hand sign-ins to you instead. The Saved sign-ins screen in the Browz app (under Automate) does the same as the commands above.

Agent tokens

Beta For the hosted remote server, in free public beta (see Hosted agents). An agent token lets a client that cannot sign in with a browser reach the remote server. Create one in the app under Automate › Connect an AI agent, or on your account page. Choose what it may do (see profiles; create, change and delete them; start them and drive their browser) and how long it lasts, up to 90 days. It is shown once.

  • Keep it in the BROWZ_AGENT_TOKEN environment variable on the machine that runs the agent. Every snippet on this page reads it from there.
  • Never paste it into a chat, a shared script or a repository. A token reaches only the remote MCP server, never the rest of your account.
  • Revoke it from the same screen; any agent using it stops at once.

Claude Desktop extension

browz.mcpb is a Claude Desktop extension: double-click it, or drag it onto Claude Desktop’s Settings › Extensions. It starts the server bundled in Browz, so Browz has to be installed and open.

Copy-paste examples: agent recipes. For agents and tools: llms.txt, the MCP tool list and the Local API OpenAPI spec.