Skip to main content
Glama

Read and drive your real, logged-in Firefox from an AI assistant — over the Model Context Protocol (MCP).

FoxBridge is two coordinated pieces:

  • An MCP server (foxbridge-mcp, this npm package) — reads your on-disk Firefox profile (cookies, history, sessions, localStorage) with zero native dependencies (Node's built-in node:sqlite), and hosts a local WebSocket bridge.

  • A Firefox extension ("FoxBridge") — runs inside your real browser and executes the server's commands with genuine WebExtension APIs, so the assistant drives your actual, logged-in tabs.

Everything runs locally. The extension sends nothing anywhere on its own.

⚠️ Security: FoxBridge grants total read/drive access to your logged-in browser sessions — live cookies (incl. httpOnly session tokens), storage, history, and the ability to act as you on any site. Only run it with an assistant you trust, and understand that any data the assistant reads goes to that assistant. Keep it local; treat cookie/token output as credentials.

What it can do

Drive your real Firefox (via the extension — ff_* tools): ff_status, ff_list_tabs, ff_open_tab, ff_activate_tab, ff_close_tab, ff_navigate, ff_reload, ff_read_page, ff_click, ff_type, ff_scroll, ff_wait_for, ff_eval, ff_fetch (call site APIs as you), ff_download (save files with your auth), ff_network (see the tab's live XHR/fetch calls), ff_get_cookies (incl. httpOnly).

Related MCP server: selenium-mcp

Demo

Ask your MCP client (Claude, etc.) things like:

> Search Google for "playwright vs puppeteer" and summarize the top 5 results.
   → opens a tab, reads the results, returns a summary

> Open my exchange dashboard, wait for the balance to load, and read it.
   → ff_navigate + ff_wait_for + ff_read_page (as the logged-in you)

> What API calls does this page make? Then call the balances endpoint and give me the JSON.
   → ff_network to discover the endpoint, then ff_fetch it with your cookies

> Download the PDF linked as "Invoice" on this page.
   → ff_download saves it to ~/Downloads using your session

Read the on-disk profile (no browser needed): list_profiles, get_cookies, get_history, get_bookmarks, get_sessions, get_local_storage, get_cache_info, clear_disk_cache.

Optional standalone Playwright browser (playwright is an optional dependency): browser_start, navigate, read_page, eval_js, tab/interaction tools. Not required for the ff_* or on-disk tools.

Install — Windows, macOS & Linux

FoxBridge is fully cross-platform. You install two parts: the MCP server (Node) and the Firefox extension. Do both.

Prerequisites (all OSes): Node.js ≥ 22.5 (for the built-in node:sqlite) and Firefox.

1. The MCP server

Recommended — via npx (works on Windows, macOS, Linux): add this to your MCP client config:

{
  "mcpServers": {
    "foxbridge": { "command": "npx", "args": ["-y", "foxbridge-mcp"] }
  }
}

Where that config file lives (Claude Desktop):

OS

Config path

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Windows

%APPDATA%\Claude\claude_desktop_config.json

Linux

~/.config/Claude/claude_desktop_config.json

For Claude Code (any OS): claude mcp add foxbridge -- npx -y foxbridge-mcp.

One-click (Claude Desktop, any OS): download the .mcpb bundle from Releases and open it.

From source (any OS):

git clone https://github.com/sinamohsenifar/foxbridge-mcp.git
cd foxbridge-mcp
npm install        # Playwright is OPTIONAL and not downloaded
npm run build
# then point your MCP config command/args at:  node /abs/path/foxbridge-mcp/dist/index.js

2. The Firefox extension

Firefox extensions are OS-agnostic — the same signed .xpi works on Windows, macOS, and Linux.

  1. Download foxbridge-extension-<version>.xpi from Releases.

  2. In Firefox: open about:addons → gear ⚙️ → Install Add-on From File… → pick the .xpi.

Firefox Add-ons store: FoxBridge is submitted to addons.mozilla.org/firefox/addon/foxbridge and is pending Mozilla review. Once approved you can install & auto-update it straight from the store — no manual .xpi needed.

For development (any OS): about:debugging → This Firefox → Load Temporary Add-on → pick extension/manifest.json.

The extension auto-connects to the server on ws://127.0.0.1:8787. Verify with the ff_status tool.

Usage

Ask your assistant things like:

  • "List my open Firefox tabs and read the active one."

  • "Open my dashboard, wait for the balance to load, and read it."

  • "Call this site's API as me and give me the JSON."

Configuration

  • BRIDGE_PORT (env) — override the bridge port (default 8787). Useful to run isolated instances.

Development

npm install        # playwright is optional and NOT downloaded automatically
npm run build      # compile TypeScript -> dist/
npm start          # run the server on stdio

Extension packaging/signing:

npm run ext:build           # build an unsigned .xpi into dist-ext/
npm run ext:submit          # submit to AMO (listed) — needs AMO API creds

License

MIT © Sina Mohsenifar

Available Tools

52 tools
browser_startA

Launch the live Firefox instance. Set useProfile to a profile name (or "" for default) to use a COPY of your real cookies/sessions; omit for a clean browser.

Inputs: headless, useProfile.

clear_cookiesA

Clear ALL cookies in the live browser context.

Inputs: no named parameters.

clear_disk_cacheA

Delete the HTTP disk cache (close Firefox first, or it rebuilds).

Inputs: profile.

clear_web_storageA

Clear localStorage, sessionStorage and Cache API for the active tab's origin.

Inputs: no named parameters.

clickC

Click an element by CSS selector.

Inputs: selector (required), button, doubleClick.

close_browserA

Close the live Firefox instance.

Inputs: no named parameters.

close_tabA

Close a tab by index (default: active tab).

Inputs: index.

eval_jsA

Run JavaScript in the active tab and return the result. Set useProfile to a profile name (or "" for default) to use a COPY of your real cookies/sessions; omit for a clean browser.

Inputs: code (required), useProfile.

ff_activate_tabA

Focus/switch to one of your real tabs by id. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: tabId (required).

ff_clear_networkA

Clear the captured network log for a real tab (call before an action to see only its new requests). Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: tabId.

ff_clickA

Click an element (CSS selector) in a real tab. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: selector (required), tabId.

ff_close_tabA

Close a real tab by id (default: active tab). Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: tabId.

ff_downloadA

Download a file to disk via the browser's download manager (uses the tab's cookies/auth for protected files). Waits for completion; returns the local path. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: url (required), filename.

ff_evalA

Run JS in a real tab (DOM + storage; not page globals). Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: code (required), tabId.

ff_fetchA

Call a URL/API from INSIDE a logged-in tab (real cookies/auth) and return status + JSON/text body. Great for scraping the site's own API. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: url (required), tabId, options.

ff_get_cookiesB

Get REAL cookies (incl. httpOnly session cookies) for a URL/domain. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: url, domain.

ff_list_downloadsA

List recent browser downloads (path, state, size). Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: limit.

ff_list_tabsA

List your real open Firefox tabs (id, url, title, active). Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: no named parameters.

ff_navigateB

Navigate a real tab to a URL and return it as data (real logged-in page). Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: url (required), tabId.

ff_networkB

List recent network requests (XHR/fetch/docs) a real tab made, with method/url/type/status — see the site's live API calls. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: type, limit, tabId, filter.

ff_open_tabB

Open a new tab in your real Firefox. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: url, active.

ff_read_pageA

Read a real tab as structured data — incl. its REAL localStorage/sessionStorage/cookies. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: tabId.

ff_reloadA

Reload a real tab (default: active). Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: tabId.

ff_screenshotA

Screenshot the visible area of a real tab (PNG). Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: tabId.

ff_scrollC

Scroll a real tab by pixels (auto-detects inner-scroll containers), or scroll an element into view via selector. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: y, tabId, selector.

ff_statusA

Check whether the real-Firefox bridge add-on is connected. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: no named parameters.

ff_typeB

Type text into an input (CSS selector) in a real tab. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: text (required), selector (required), tabId.

ff_wait_forB

Wait for an element (CSS selector) to appear in a real tab — for dynamic/scraped pages. Operates your REAL running Firefox (needs the bridge add-on loaded).

Inputs: selector (required), tabId, timeoutMs.

get_bookmarksC

Read all bookmarks.

Inputs: profile.

get_cache_infoB

Report HTTP disk-cache size and entry count.

Inputs: profile.

get_cookiesA

Read cookies from the on-disk profile (works for closed tabs). Optional host filter.

Inputs: host, profile.

get_historyB

Read browsing history, most recent first.

Inputs: limit, profile.

get_live_cookiesB

Get cookies from the live browser context. Set useProfile to a profile name (or "" for default) to use a COPY of your real cookies/sessions; omit for a clean browser.

Inputs: useProfile.

get_local_storageB

Read localStorage for every origin (LSNG + legacy). Optional origin filter.

Inputs: origin, profile.

get_sessionsC

Read current/last session: open + closed tabs.

Inputs: profile.

go_backB

Go back in the active tab's history.

Inputs: no named parameters.

go_forwardB

Go forward in the active tab's history.

Inputs: no named parameters.

hoverC

Hover the mouse over an element.

Inputs: selector (required).

list_profilesA

List local Firefox profiles.

Inputs: no named parameters.

list_tabsA

List open tabs (index, url, title, which is active). Set useProfile to a profile name (or "" for default) to use a COPY of your real cookies/sessions; omit for a clean browser.

Inputs: useProfile.

open_tabA

Open a new tab (optionally navigate to a URL) and make it active. Set useProfile to a profile name (or "" for default) to use a COPY of your real cookies/sessions; omit for a clean browser.

Inputs: url, useProfile.

press_keyA

Press a keyboard key (e.g. Enter, Tab, Escape). Optional selector to focus first.

Inputs: key (required), selector.

read_pageA

Capture the active tab as structured data (DOM/text/links/controls/cookies/storage/network/console).

Inputs: no named parameters.

reloadA

Reload the active tab.

Inputs: no named parameters.

screenshotC

Take a PNG screenshot of the active tab (returned as an image).

Inputs: fullPage.

scrollC

Scroll the page by pixels, or scroll an element into view.

Inputs: y, selector.

select_optionB

Select an in a by value or label.

Inputs: value (required), selector (required).

switch_tabB

Switch the active tab by index.

Inputs: index (required).

type_textB

Type text into an input/textarea by selector (clears it first by default).

Inputs: text (required), selector (required), clearFirst.

wait_forC

Wait for an element to appear.

Inputs: selector (required), timeoutMs.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.9/5.0

    Scored across 52 tools

    Disambiguation2/5

    Many tools have overlapping purposes, especially between ff_ prefixed (real Firefox) and non-prefixed (browser instance) versions, e.g., click vs ff_click, navigate vs ff_navigate, and multiple cookie-related tools. Agents may easily misselect.

    Naming Consistency2/5

    Naming conventions are mixed: some use snake_case (browser_start, clear_cookies), some use ff_ prefix (ff_click), and some are simple verbs (click, hover). No consistent pattern across the tool set.

    Tool Count3/5

    52 tools is high but justified by comprehensive browser automation scope. However, many tools are duplicated for two execution contexts (real Firefox vs. clean instance), which could be consolidated.

    Completeness4/5

    Covers a wide range of browser interactions: navigation, clicking, typing, cookies, storage, history, bookmarks, network, downloads, tabs. Missing bookmark creation/deletion but overall very complete.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that exposes Firefox browser automation capabilities through the Model Context Protocol, enabling AI assistants to control web browsers for navigation, interaction, and data collection tasks.
      4
      BSD 3-Clause
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI assistants to operate a real, logged-in Firefox session through an extension, including tab and history management, page reading, screenshots, and clicking, typing, or scrolling on domains the user approves.
      12 npm
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables AI agents to control the user's installed Firefox with real logins, saved passwords, bookmarks, and extensions while offering all Playwright MCP tools and options. It runs on a copied profile so the daily browser remains untouched and supports multiple profiles or accounts.
      25
      MIT