BitBrowser MCP Server: Let ChatGPT Control 100 Browser Profiles Autonomously

Ten months ago the only way to control 100 antidetect browser profiles was a Python script, a REST client, and a lot of coffee. Since BitBrowser shipped its local MCP server in version 7.1.5, that job now fits in a single ChatGPT prompt.

This article walks through the exact setup: the port, the token, the JSON block, the prompts that actually work, and the pitfalls that will bite you at profile 40. If you run affiliate accounts, farm airdrops across dozens of wallets, or manage social ops for a client roster, the workflow below is the shortest path from "I have an idea" to "the browsers are already running."

What BitBrowser MCP actually does

MCP (Model Context Protocol) is Anthropic's open standard for letting AI assistants talk to local tools and data sources through a standardized JSON-RPC interface. Since late 2024 it has been adopted by Claude Desktop, Cursor, Cline, Continue, WorkBuddy, Zed, and OpenAI's ChatGPT via the Custom Connectors surface.

BitBrowser exposes its local API on http://127.0.0.1:54345 as an MCP endpoint at /mcp. Once your ChatGPT client is pointed at that endpoint with the right x-api-key header, the model can:

• Create new browser profiles with real, non-linked fingerprints
• Launch, close, or delete profiles by ID or by name pattern
• Update proxy settings, timezone, UA, WebGL, Canvas, and font values
• Query the current state of every profile in your workspace
• Group and tag profiles for filtered batch operations

No Python. No requests library. No hand-rolled retry logic. The LLM writes the tool call, MCP validates it, BitBrowser executes it, the result flows back into the chat context.

Prerequisites

Before you connect anything, three things need to be in place:

1. BitBrowser desktop app version 7.1.5 or later. Older builds do not expose the MCP endpoint. Update from the app or download fresh from the site.
2. A ChatGPT client that speaks MCP. ChatGPT Desktop with Custom Connectors enabled works out of the box. If you are on the web interface only, use a bridge like mcp-proxy or wrap the local API as a Custom GPT Action against an OpenAPI schema.
3. Your machine reachable from wherever ChatGPT runs. If you use the desktop client, everything is local. If you use ChatGPT web, you will need a tunnel (Cloudflare Tunnel, ngrok, Tailscale Funnel) pointing at 127.0.0.1:54345.

Step 1: Enable the Local API and mint a token

Open BitBrowser, go to System Settings, and click LocalAPI. Two toggles matter:

• Enable LocalAPI — turns the server on. It listens on port 54345 by default.
• LocalAPI Token authentication — forces every request to carry a bearer token. Turn this on. Always. An unauthenticated local API on a shared machine is a bad idea, and the token adds four seconds of setup.

Copy the token that appears in the field. It looks like 2b582faedd9941408e0aa14cad2d45ac. Store it somewhere the ChatGPT config can read. Do not paste it into a public repo.

Scroll to General Settings. Under Adaptation Smart Agent Tool you will see the MCP configuration snippet, ready to copy.

Step 2: Register the MCP server in ChatGPT

In ChatGPT Desktop, open Settings → Connectors → Add custom MCP server. Paste the config block below, swapping in your own token:

{
  "bitbrowser": {
    "url": "http://127.0.0.1:54345/mcp",
    "headers": {
      "x-api-key": "2b582faedd9941408e0aa14cad2d45ac"
    }
  }
}

Restart the client. If the connection succeeds, bitbrowser shows up in your available tools list. If it fails, three things to check:

• BitBrowser is running and the LocalAPI toggle is green.
• The token matches (whitespace at either end kills it).
• Nothing else is bound to port 54345. lsof -i :54345 on macOS or netstat -ano | findstr :54345 on Windows tells you.

Step 3: The first prompt

Open a fresh chat. Type this:

Create 10 new BitBrowser profiles named airdrop_01 through airdrop_10. Set each one to use Chrome 128, UTC-5 timezone, and a US residential proxy from my Proxy-Seller account (the one already saved in BitBrowser). Group them under the tag "airdrop_wave_9". Do not launch them yet.

ChatGPT parses the intent, calls the MCP browser.create tool ten times with the right arguments, and reports back with the list of new profile IDs. On a mid-range laptop this takes 18 to 25 seconds for ten profiles. For 100 profiles, expect 3 to 4 minutes because BitBrowser serializes profile writes to avoid fingerprint collisions.

Step 4: Batch operations that used to require a script

The prompts below all work on a well-configured connector. Each maps to one or more MCP tool calls under the hood.

Launch every profile in the "airdrop_wave_9" group, one every 8 seconds
to avoid a proxy pool burst.

Find all profiles created before 2026-06-01 that have not been opened
in 30 days. List them and ask before deleting.

Update the proxy on profiles tiktok_us_01 through tiktok_us_20 to the
new mobile pool: gate.smartproxy.com:7000, sticky sessions, 10 minute TTL.

Export the fingerprint config of profile fb_bm_lead_02 as JSON, then
create three more profiles with the same base but rotate Canvas noise,
AudioContext hash, and WebGL vendor.

A useful pattern is to keep a short markdown file of your reusable prompts next to your project notes. Version-control the file. Your prompts become the source-of-truth automation, not scripts.

Direct API access, for when the LLM is overkill

MCP is not the only way in. The same endpoints answer regular HTTP calls, which is faster for tight loops. The old REST reference still applies. This BitBrowser Local API reference on HackMD documents every endpoint, request shape, and response code. A curl to open a profile:

curl -X POST http://127.0.0.1:54345/browser/open \
  -H "x-api-key: 2b582faedd9941408e0aa14cad2d45ac" \
  -H "Content-Type: application/json" \
  -d '{"id":"6f3a8b12c4d5e6f7a8b9c0d1e2f3a4b5"}'

The response includes the CDP WebSocket URL. Pass it to Puppeteer or Playwright with connect({ browserWSEndpoint }) and you are automating the real browser session the profile just opened. MCP for orchestration, REST for the hot path. Both stay useful.

Extending the setup to mobile: BitCloudPhone

Browser profiles are half the multi-account picture. TikTok Shop, Snapchat, BeReal, Tinder, and most Southeast Asian marketplaces (Shopee, Lazada, Sendo) fingerprint far harder on the mobile app than they do on desktop web. That is where cloud phones come in.

BitCloudPhone runs the same account isolation story on real device hardware. The Android side, BitCloudPhone Android, gives you ARM instances in physical device farms rather than emulator stacks. Every phone has its own IMEI, MAC, and sensor pattern. For US dating apps, US delivery gigs, or Snap growth work, the BitCloudPhone iOS service exposes real iPhone hardware you can drive over ADB-equivalent APIs. Both surfaces will get the same MCP treatment in a coming release; for now they are controlled via REST, from the same script that talks to BitBrowser.

Real limitations you will hit

The stack is new. Three things to know before you scale:

• Rate limits at the OS level. macOS caps outbound connections per process. Once you push past 60 concurrent open profiles, you will see connection resets that look like proxy failures but are actually kernel throttling. ulimit -n 4096 fixes it on the shell you launched BitBrowser from.
• MCP tool descriptions get long. ChatGPT's context budget spends real tokens loading the BitBrowser tool schema on every turn. On the Plus tier this eats about 6% of your context per turn. On Team or Enterprise it is negligible. If you are on the free tier, expect to compact the chat manually every 20 turns.
• The LLM will hallucinate a profile ID once in a while. Always ask it to list profiles first, then act on the returned IDs, rather than trusting a name-based lookup. This one habit prevented three accidental deletes in my first week.

FAQ

Does this work with Claude, Cursor, or Cline instead of ChatGPT?
Yes. MCP is client-agnostic. The same JSON config drops into Claude Desktop's claude_desktop_config.json, Cursor's mcp.json, or Cline's settings. The tool names and behavior stay identical.

Can I run BitBrowser MCP on a headless Linux VPS?
Not yet. The MCP server is bundled with the desktop client, which needs a GUI session. Workarounds exist (Xvfb + VNC), but for VPS deployments the REST API is the supported path.

How many profiles can one machine hold?
Storage-wise, unlimited within your disk budget. Runtime, expect 30 to 60 concurrent open profiles on 16GB RAM, 100 to 150 on 32GB. Beyond that, split across machines and coordinate via the API.

Is the LocalAPI token safe to keep in a config file?
On your own machine, yes. On a shared or cloud machine, no. Rotate the token weekly and keep it in a secrets manager (1Password CLI, Bitwarden, macOS Keychain) that the connector reads at startup.

Does MCP replace Puppeteer and Playwright?
No. MCP orchestrates profile lifecycle. Puppeteer and Playwright still drive the actual browser session inside a launched profile. The two layers compose. You will use both.

Where to take it from here

The interesting compound effect is when the ChatGPT session is also connected to your other tools — Google Sheets for account lists, Gmail for verification codes, Notion for SOPs. At that point the loop closes: "read the next 20 rows of the sheet, create a BitBrowser profile for each, launch them, register each one on TikTok Shop, and log the result back to the sheet." Ninety minutes of manual work becomes six.

Start with ten profiles. Confirm the setup end to end. Then scale. Small, boring wins first.

---

Affiliate disclosure: This post contains affiliate links. If you sign up for a paid BitBrowser or BitCloudPhone plan through the links above, I may earn a small commission at no additional cost to you. All product testing was done on my own paid accounts.