Download Log in Sign up

Docs

Browz for AI agents

Pick the AI you use. Browz becomes a set of tools it can call: list and create profiles, start them, open pages, fill in forms and take screenshots, each in its own isolated browser. Why agents need their own browser is on Browz for AI agents.

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.

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.

Apps

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

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

Download browz.mcpb (double-click to install)

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

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

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.

APIs and SDKs

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

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

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

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

Add to Cursor

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

Add to Cursor

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

Add to VS Code

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

Add to VS Code

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}"
      }
    }
  }
}

Agent frameworks

browser-use

On the computer with Browz

Install

pip install browser-use   # plus the Browz Python SDK: sdk/python, or pip install ./sdk/python

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   # plus the Browz TypeScript SDK in sdk/typescript

Drive a fresh Browz profile (it is deleted afterwards)

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

await withBrowzSession(async (session) => {
  const browser = await localBrowser.connect(stagehandConnectArgs(session));
  const stagehand = await Stagehand.create({ browser });
  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

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

Agent tokens

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.