extension .dev MCP
Build, run, debug, test, preview, and ship browser extensions for Chrome, Firefox, Edge, and Safari from an AI agent.
Scaffold extensions from 50+ templates or plan new popup, sidebar, options, content-script, background, newtab, or devtools features.
Validate manifests across browsers and build production bundles, including store-ready zips and Safari macOS apps.
Run dev sessions with HMR in Chromium, Firefox, and Safari, or launch production builds.
Inspect live DOM, shadow roots, console logs, storage, loaded extensions, and open surfaces; evaluate code and trigger actions, commands, reloads, and navigation.
Run assertions that return pass, fail, or inconclusive verdicts.
Analyze built extensions on disk for size, permissions, entry points, and store readiness.
Preview in-progress builds in a web emulator and create or revoke public preview links.
Manage extension.dev logins, create workspaces and projects, publish projects, promote release channels, and check release/store status.
Submit builds to Chrome Web Store, Firefox Add-ons, Edge Add-ons, and App Store review, with dry-run support and human approval for real submissions.
Detect, install, and remove browsers; diagnose sessions; verify Chrome themes; and search docs.
Allows running and debugging extensions in the Brave browser during development.
Enables submitting extension builds to the Chrome Web Store for publication and release management.
Allows running and debugging extensions in Firefox during development.
Provides authentication via GitHub device-code flow for accessing platform tools such as publishing and promoting builds.
Allows running and debugging extensions in LibreWolf during development.
Allows running and debugging extensions in Opera during development.
Allows running and debugging extensions in Safari on macOS during development.
Allows running and debugging extensions in Vivaldi during development.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@extension .dev MCP scaffold a new popup extension using React"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
extension.dev MCP

Build, run, debug, test and ship Chrome, Firefox, Edge and Safari extensions from your AI agent.
extension.dev MCP is the MCP server for building browser extensions in Claude Code, Cursor, VS Code, Codex and any MCP client. Your agent creates an extension, runs it, proves it works and ships it to four stores.
Documentation · Tools · Skill · Changelog · Troubleshooting · Discord
Install
claude mcp add extension-dev -- npx @extension.dev/mcp --features=local,platformOr install the extension-dev plugin, the MCP server pinned to one published version plus the browser-extension skill, in one step:
/plugin marketplace add extensiondev/skill
/plugin install extension-dev@extensiondev
Other clients take the same server as .mcp.json; every client's block, with a local-only form, is on Install in your client.
{
"mcpServers": {
"extension-dev": {
"command": "npx",
"args": [
"@extension.dev/mcp",
"--features=local,platform"
]
}
}
}The local tools need no account; the platform tools, on with --features=local,platform, ask for a login the first time they reach extension.dev. Add extras (--features=local,platform,extras) to list extension_theme_verify and extension_network.
Related MCP server: @nimbus21.ai/chrome-devtools-mcp
Your first prompt
Build it and prove it works
Create a Chrome and Firefox extension that highlights external links, run it, and prove the content script injected.
The agent scaffolds from a template, starts the dev session, a browser opens with the extension loaded, and extension_assert answers with a verdict instead of a guess.
Then ship it
Submit this build to the Chrome Web Store and Firefox Add-ons as a dry run and tell me what is missing.
extension_submit defaults to a dry run, so nothing goes into review until a workspace owner approves the real submit.
Ship to four stores
extension_submit sends a built extension into review at the four stores through extension.dev, which holds your store credentials. It defaults to a dry run, and a real submit waits for a workspace owner to approve that exact act on extension.dev: the server never submits or publishes on its own. Reaching the App Store needs no Mac: the Safari lane signs with keys the platform holds encrypted at rest, under the same approval.
The platform tools need a login once. You approve a code at extension.dev/device; the project-scoped token stays on this machine, is never returned to the agent, and lives at most 7 days. No project yet? Request access at extension.dev.
npx @extension.dev/mcp login --project <workspace>/<project>Details under Platform tools.
Watch it work

What it does
Extensions fail silently, with content scripts that never inject and panels that never open, so these tools give the agent eyes on the live browser.
Ship: validate the manifest cross-browser, build, share a preview, promote, submit
Scaffold from 50+ templates, or add a popup, sidebar or content script
Run the dev server with HMR in every browser below
See the live DOM, logs from every context,
chrome.storage, the loaded extensionsAct: evaluate code in any context, trigger the action button and commands, reload
Test:
extension_assertanswerspass,failorinconclusive, the last naming the evidence that would settle it
Every engine command runs the project's own engine when it has one, else the version this server pins (Engine pinning).
Supported AI agents
Works in | How it connects | |
Claude Code |
| |
Cursor | One-click link, Install | |
VS Code | One-click link for Copilot agent mode, Install | |
Codex |
|
Any other MCP client takes the same .mcp.json block.
Supported frameworks
Build a browser extension with | Ask your agent | |
React (11 templates) | "Create a React side panel extension and run it in Chrome" | |
Preact (6 templates) | "Build a Preact new tab page with a router and test it in Firefox" | |
Vue (6 templates) | "Make a Vue popup that saves notes to chrome.storage" | |
Svelte (6 templates) | "Scaffold a Svelte content script that highlights links" | |
TypeScript (11 templates) | "Start a TypeScript DevTools panel that stores data in SQLite" | |
JavaScript (26 templates) | "Add a popup to my plain JavaScript extension and ship it to Edge" |
Every template builds for Chrome, Edge and Firefox, and the same project ships to Safari through the App Store lane.
Requirements
Node 22.12 or later.
A Chromium or Firefox browser, or
extension_browsersinstalls one.macOS with Xcode only for a local Safari session; the App Store lane needs no Mac.
An extension.dev login only for the platform tools.
Browsers
extension_dev opens the extension in the browser you name. The Chromium family and Firefox get HMR, control, eval, inspect and assert, and so does any Chromium or Gecko binary by path. On macOS with Xcode, browser: "safari" builds the app, opens it, reloads it on every save and streams its logs; no eval, no extension_inspect, limits under Safari.
Security
Local by default. Every local tool runs on your machine. The control channel (
extension_storage,extension_reload,extension_open,extension_dom_snapshot) is same machine, same user, on unlessextension_devis called withallowControl: false.The eval gate.
extension_evalstays off untilextension_devis called withallowEval: true. A session never grows a gate on a second call: callextension_devagain withreplace: true(Session gates).extension_elementclicks, fills, reads and waits for one element, and sends trusted mouse and keyboard input (move, press, release, type, key, scroll) that pages read asisTrusted: true, over the debug port with no gate, since it runs no caller code.What leaves the machine. Nothing until you ask. A platform tool is answered by extension.dev's hosted lane at
mcp.extension.dev, which gets a credential that lasts ten minutes, never the login.--no-shiprefuses every call that puts something in front of other people.Nothing until you ask. The local tools send nothing to extension.dev. A platform tool is answered by extension.dev's hosted lane at
mcp.extension.dev: this server exchanges the stored login at www.extension.dev for a credential that lasts ten minutes and sends the lane that credential, the tool's arguments and the project ref, never the login, a file path or theapioverride. A store check or a listing sync also sends what it read from the project (the text ofSTORE.md, the icon and screenshot sizes and digests, the git HEAD); a listing image is uploaded to www.extension.dev only when the listing write needs it. A shared preview uploads the build it just made, a project created from a folder uploads that folder, a capture sync uploads the capture files, and a login stores a project-scoped token locally. Signing in and out, a create and its device approval, a preview, a build download, a capture sync and a share create run on this machine.--no-shiprefuses every call that puts something in front of other people.Approvals stay human. A real submit, a channel promotion and a share revoke answer
approval-required; a workspace owner approves the exact act on extension.dev, the call is repeated with the returnedapprovalId, and the server never approves anything itself.extension_submit_checkcarries the reads and the asks underreadOnlyHint: true;extension_submitcarries the act.Untrusted text from pages comes back inside an
<untrusted-data-ID>fence, and every tool carries MCP annotations.
Telemetry
extension_create sends one draft_seeded event to us.i.posthog.com after a scaffold (template slug, source and commit, a random per-process id, never a path or a name), and the platform tools send a per-install id header. EXTENSION_DEV_NO_TELEMETRY=1 or DO_NOT_TRACK=1 stops both (payload).
Hosted server
https://mcp.extension.dev/mcp serves the platform reads and promotions over Streamable HTTP: a client connects with the URL alone, signs in at www.extension.dev through OAuth, and gets extension_workspace, extension_project_create, extension_builds (reads), extension_builds_act, extension_release_status, extension_release_promote and extension_auth (status only). Local tools, publish, submit and share links stay on the stdio server.
claude mcp add --transport http extension-dev https://mcp.extension.dev/mcpFlags
Flag | Environment variable | Default | Effect |
|
|
|
|
|
| off | Refuses publish, promote, a real submit, a store act (the listing sync included), a shared preview, a share create or revoke |
|
| unset | Refuses any call that names another project |
none |
| unset | An access token in place of the device login, for CI |
none |
| off | Never opens the approval page in the default browser |
none |
| off | Turns off the |
none |
| this release's pin | The engine version run when the project has none of its own |
none |
| unset | Runs every engine command from a compiled engine checkout or one bin file |
login, logout, whoami and release promote run headless; see Server flags.
Tools
The local group scaffolds, builds, runs, inspects, drives and asserts; the platform group logs in, shares, promotes, submits, reads builds, releases and approvals, and runs a published build with extension_try; the extras group, off unless named, verifies a Chrome theme and stubs network responses. Every tool has a page under the tool reference, generated from the schema the server registers, with its inputs, whether it only reads, the gate it needs and a prompt that reaches for it.
Pair with the skill
This server gives agents hands; @extension.dev/skill gives them judgment: cross-browser rules, silent-failure gotchas, debugging playbooks and the store checklist.
npx skills add extensiondev/skillQuestions
How do I publish a Chrome extension from Claude Code or Cursor?
Add the server with the line under Install, then ask the agent to submit the build. extension_submit defaults to a dry run, and a real submit waits for a workspace owner to approve it on extension.dev.
Can an AI agent submit to the App Store without a Mac?
Yes. The Safari lane signs with keys the platform holds encrypted at rest; only a local Safari session needs macOS with Xcode.
Does it need an account?
The local tools need none. The platform tools ask for an extension.dev login the first time they reach extension.dev.
Troubleshooting
Every refusal carries an error code and a hint (error.hint) naming what to change or the next call. The five most common:
E_TOOL_DISABLED: the tool's group is off, or the call reaches outside this machine in no-ship mode. Add the group the hint names (platformorextras) to--features, or drop--no-ship, in the client's config, then call again.approval-required: have a workspace owner approve the act at the link, then repeat the call with the same arguments and the returnedapprovalId.E_AUTH_REQUIREDorE_AUTH_EXPIRED: the login lives at most 7 days. Runextension_auth(action: "login",project: "<workspace>/<project>"), then call again.E_NO_SESSION: nothing is running. Startextension_dev, thenextension_waitfor ready.extension_evalrefused: the session started without the gate. Callextension_devagain withallowEval: trueandreplace: true; reads need no eval.
extension_doctor names the broken leg of a session. After a new version lands a tool may answer E_SERVER_STALE: run /mcp, pick extension-dev, and call again. More under When it fails.
Community
Help and feedback on Discord; templates at templates.extension.dev; issues at extensiondev/mcp.
License
Apache-2.0 (c) 2026 Cezar Augusto and the extension.dev collaborators. See LICENSE.
Available Tools
32 toolsextension_add_featureARead-onlyIdempotent
Plan a new feature surface for an existing extension. This returns step-by-step instructions, the manifest additions to make, and reference templates from the extension.dev catalog. It modifies no files: apply the returned plan yourself.
Inputs: feature (required), projectPath (required), framework.
extension_analyzeARead-onlyIdempotent
Analyze a BUILT extension on disk: file sizes, declared entry points, permissions, bundle composition, and store-readiness checks. This is static only: it reads dist/ from the filesystem and never touches a browser, so build first with extension_build. Use extension_inspect for a running extension's live DOM and console.
Inputs: projectPath (required), format, browser.
extension_assertAIdempotent
Run a test stage against a live dev session: state expectations and read one verdict for each, instead of reading a blob and hand-rolling the judgement. Every expectation comes back pass, fail or inconclusive, where inconclusive means this platform cannot cover the question today and the verdict says what would settle it. An inconclusive check is never a pass. Start the session with extension_dev; use extension_inspect or extension_logs when you want the raw reading instead of a verdict.
Inputs: expect (required), projectPath (required), browser, timeout.
extension_authADestructive
Sign this machine in to extension.dev, report that login, or clear it. Pass action:'status' (the default) to name the workspace and project the stored token is scoped to and when it expires, never the token itself; that identity comes from the stored token alone, and does not change with the current working directory or whichever project folder you are in. Status also asks the platform's whoami endpoint whether that credential actually resolves there: the answer rides value.server.verdict as confirmed, refused or unavailable (when the server could not be reached), with status logged-in for the first and last and refused-by-server for the second, so a local file claiming a login the server refused is never reported as logged in. Pass action:'login' for a two-phase flow: call with project to get a code plus a URL the user authorizes at extension.dev/device, then call again with the returned deviceCode. GitHub federation happens server-side, so no GitHub token lands on this machine. Minted tokens live at most 7 days, server-enforced, so CI must re-mint before expiry on the console's project settings, Access tokens page. Pass action:'logout' to delete the local credentials only (with project, just that project's login); the token stays valid server-side until it is revoked at the URL the response returns. Several logins live side by side on one machine, one per workspace/project, and status lists them all under logins. To sign in to several existing projects of one workspace at once, pass projects instead of project: one approval, one stored token per project.
Inputs: api, action, project, projects, +1 more.
extension_browsersADestructive
Find, install and remove the browsers Extension.js tooling can launch. Pass action:'detect' (the default) to scan both system-installed and managed browsers, and report each one's binary path, version, engine and debugger support. Pass action:'list' for the managed cache this tool downloads into, with sizes on disk. Pass action:'install' to download a managed binary: several hundred MB in one blocking call, so allow a generous client timeout. Pass action:'uninstall' to remove managed binaries; it never touches a system install.
Inputs: all, action, browser, browsers.
extension_buildAIdempotent
Build a browser extension for production. The output lands in dist//. Pass zip:true to also package a .zip for store submission. With browser:'safari' the build converts the extension into a macOS app through Xcode, and bundleId sets the identifier it ships under. The build refuses a manifest with build-blocking errors unless you pass skipValidation:true, because such a manifest yields a broken bundle the bundler itself never flags.
Inputs: projectPath (required), zip, mode, silent, +9 more.
extension_createA
Create a browser extension project from a template in the extension.dev catalog. Call extension_templates first to see what is available. The scaffolder may initialize a git repository in the new project (with a first commit), and it also writes store metadata and a .gitignore of its own. Read the result's defaultsApplied block for the decisions this tool can read back: parent directory, template, package manager, target browser and whether a git repository was initialized by this call.
Inputs: projectName (required), install, template, parentDir.
extension_devA
Run the extension while you edit it: dev build, hot module replacement, and a browser with the extension loaded. Reach for this first when the ask is "run my extension". ONLY this tool unlocks the control channel that extension_storage, extension_reload, extension_open and extension_dom_snapshot need (allowControl:true) and the eval channel that extension_eval needs (allowEval:true, which implies allowControl, so you never need to pass both). Use extension_start instead to run the production build in a browser. The result carries the process info that extension_wait and extension_inspect need.
Inputs: projectPath (required), host, port, browser, +12 more.
extension_docs_searchARead-onlyIdempotent
Find pages in the Extension.js and extension.dev docs by keyword, each with a short excerpt. Use it before answering from memory on anything version-specific: a CLI flag, a manifest field across browsers, a store submission rule. Free and needs no login.
Inputs: query (required), api, limit.
extension_doctorARead-onlyIdempotent
Diagnose a dev session end to end: ready contract, dev-server process, control-port agreement, control channel, eval token, executor, browser liveness. This returns one {check, status, detail, remediation?} per leg, in dependency order. Read a 'skip' as blocked, not as a pass: it names the check that blocked it. A session started without allowControl comes back ok:true with status 'read-only', not as an error: its control channel is off by choice. Run this first when any act tool (storage, reload, eval, open) errors unexpectedly. Call it with no projectPath for a pre-flight environment check (node, the Extension.js CLI, the template cache) before any project exists.
Inputs: browser, projectPath.
extension_dom_snapshotARead-onlyIdempotent
Take a shallow structured DOM snapshot of one chosen surface through the agent bridge (localhost only; the snapshot itself needs no CDP, but listTargets and tabUrl resolution ask the browser directly and need the session's debug port: CDP page targets on Chromium, RDP tab descriptors on Firefox): element counts, extension roots, open shadow roots, optional byte-capped HTML, and optional recent console lines. This is the SURFACE PICKER: the only tool that reads an open extension surface by name (context: popup, options, sidebar, devtools) or an override page, the only one that takes a numeric chrome.tabs id, and the only one that enumerates what is open (listTargets for CDP targetIds and RDP tab actors, listTabs for numeric tab ids). An ambiguous tabUrl returns the candidates instead of guessing. It does not pierce closed shadow roots, run selector probes, or navigate: use extension_inspect for those, and for a deep read of an already-open web page. Start the session with allowControl:true (extension_dev).
Inputs: projectPath (required), tab, url, tabUrl, +8 more.
extension_evalADestructive
Evaluate an expression in a running extension context. Start the session with allowEval:true (extension_dev), which writes a 0600 session token; without that token every route of this tool, the debug port included, answers eval-disabled. Context defaults to 'background', except on a Chromium MV3 session (the default template) where it defaults to 'page', the active tab; pass context:'background' to evaluate in the service worker, which on Chromium goes over the debug port. Debug-port evaluates run with a user gesture, so gesture-gated APIs (permissions.request, sidePanel.open) can succeed here and still fail when the extension's own code calls them. For content and page, pass url to pick the tab, or omit both url and tab for the active tab; a numeric tab only disambiguates. Extension surfaces (popup, options, sidebar, devtools) and override pages (newtab, history, bookmarks) need no tab id but must already be open: open one with extension_open first, because a closed one returns an explicit error. On a Chromium MV3 session those pages, and context:'page' with a chrome-extension:// url, evaluate over CDP, the inspector path the extension page CSP does not govern; elsewhere they evaluate over the in-bundle relay. On Firefox a document whose content security policy forbids eval (the extension's own pages, or a site's) is evaluated over the debugger protocol instead, which takes one expression; a page inside the extension that is no declared surface (pages/*) is reached the same way by context:'page' and its moz-extension:// url once a tab shows it. Call extension_dom_snapshot with listTabs:true to enumerate {tabId, url, title}.
Inputs: expression (required), projectPath (required), tab, url, +3 more.
extension_inspectAIdempotent
Inspect a running extension deeply over the browser's debugger protocol: full HTML (open shadow roots of #extension-root and [data-extension-root] hosts inlined; other shadow roots are not crossed by html, dom_snapshot or probe), DOM structure, content-script injection, console messages, and CSS selector queries through probe. This is the ONLY tool that pierces closed shadow roots (deepDom), runs selector probes, and navigates a tab to url before reading it. It reads a web or override page and picks the first inspectable target, or the first whose url contains url; it cannot address an extension surface by name and takes no chrome.tabs id. Use extension_dom_snapshot to choose which tab or which open surface (popup, options, sidebar, devtools) to read, or to enumerate what is open. Use extension_analyze for a built extension's files and sizes on disk. Chromium rides the Chrome DevTools Protocol and needs the session's debug port, not allowControl. Firefox is fully paired: summary, meta, html, dom_snapshot, extension_roots and probes ride the agent bridge and need allowEval:true, console rides the RDP watcher replay on engine 4.0.15 and later, and deepDom needs an MV2 session with host permissions for the target url, because the Firefox MV3 background CSP blocks bridge evals. This requires an active dev or start session.
Inputs: projectPath (required), url, probe, browser, +3 more.
extension_list_extensionsARead-onlyIdempotent
List the extensions in the running dev browser: id, name, version, and, on Chromium, live contexts. This session's own extension carries ownExtension:true, with name and version from the ready contract even when the browser exposes no identity. Chromium rides the Chrome DevTools Protocol, so an entry needs at least one live context, and a dormant MV3 service worker may be absent until it wakes. Firefox rides the RDP root actor (listAddons, engine 4.0.15 and later), so entries are installed add-ons regardless of contexts, are marked temporarilyInstalled where relevant, and carry no contexts. Other extensions' contexts are never attached to or evaluated in. This requires an active dev or start session.
Inputs: projectPath (required), browser.
extension_logsARead-onlyIdempotent
Read or stream logs from every context of a running dev session (service worker, content scripts, popup, options, sidebar, devtools, pages) in one ordered timeline. This reads the same agent-bridge plane as the extension logs CLI: a one-shot returns the most recent matching lines from logs.ndjson, and follow:true connects to the live control channel, receives the broker's replay of its recent ring (up to 5,000 events, counted in value.replayed) and then the frames that arrive during followMs (value.live). This requires an active extension_dev session.
Inputs: projectPath (required), tab, url, level, +7 more.
extension_manifest_validateARead-onlyIdempotent
Validate a manifest.json across browsers. This reports missing fields, invalid permissions, dangling file references, and cross-browser compatibility issues. Read buildBlocking for the errors that make extension_build refuse.
Inputs: browser, browsers, projectPath, manifestPath.
extension_openA
Open an extension surface, or replay an event, in a running session. Pass surface:'popup', 'options' or 'sidebar' to open a UI surface, or 'newtab', 'history' or 'bookmarks' to open the matching chrome_url_overrides page in a tab (always a tab, resolved by the server, never sent to the engine). On Chromium, when Chrome refuses the sidebar for lack of a user gesture, the server opens the real panel through a synthetic click on the extension's own page and says so in warnings; if that fails too it renders the sidebar document as a tab. Pass surface:'devtools' to open the browser's DevTools on a tab (the one url matches, else the first web page) and show the extension's panel there, picked by panel title when there are several: Chromium only, over CDP Target.openDevTools, headed or headless; the result names the panel document's url, which extension_eval reads with context 'page' and that url (the panel is no tab, so the tab-based readers do not reach it). Pass surface:'action' to trigger the toolbar action, which opens its popup or replays chrome.action.onClicked when there is none. Pass surface:'command' with name to replay a chrome.commands.onCommand shortcut. Note that action and command replay invoke your listener without a user gesture, so the gesture-derived activeTab grant does not apply; the engine's own frame is returned as is. Start the session with allowControl:true (extension_dev).
Inputs: projectPath (required), tab, url, name, +7 more.
extension_preview_webA
Preview an in-progress extension in the web emulator, with no real browser. This builds the project (unless build:false) and previews dist/. Pass share:true unless you are working inside the extension.dev monorepo: it uploads the build and returns a link anyone can open, with no install, sign-in or dev server, and it is the only lane that works from an npm install of this server. Sharing also serves the build as a zip, so it hands over the built code; read the share property before using it. The default lane instead returns a deep link over the dev-only preview://build scheme, which resolves only against a preview.extension.dev dev server on this machine, so it is for people developing extension.dev itself. Call extension_shares to list and revoke every link shared this way, so one never vanishes with this response.
Inputs: projectPath (required), open, build, probe, +6 more.
extension_project_createA
Create an extension.dev project for an extension that does not have one yet, without opening the console. Use it right after extension_create and extension_build, once the extension's source is pushed to a GitHub repository, and BEFORE extension_auth: extension_auth can only log in to a project that already exists, and this tool is what brings that project into existence. Ask for nothing but the project slug and the repo; the platform finds the GitHub App installation on the approving account itself, and if there is none it returns a connect link to open. Two-phase, like login: the first call returns a code and a URL where a signed-in member of the workspace approves creating exactly this project; call again with the returned deviceCode to finish. The approval mints a provisioning grant that lives minutes, can only create the one named project, and is never stored on this machine. On success the platform creates the project and its mirror repository, and dispatches the first build when it can: the answer says in firstBuild whether one was dispatched and, when none was, why (no commits, no build workflow, a spent build allowance, a paused dispatch). Then run extension_auth (action: login) against the new project, and extension_publish to share it. To create several projects in one workspace under one approval, pass projects instead of project and repo: the approval page lists every name, each project is created by its own request, and each one's 7-day token is stored as that project's login, so no extension_auth call is needed afterwards. A list takes a few calls to finish: while projects remain the answer is status 'creating' with the same deviceCode to call again, and the grant is held in this server's memory only. One approval creates at most 10 projects, the cap the platform states in its login config, because it creates at most 10 per hour for one approving account; the next 10 can start in a new call once that limit allows. A longer list is refused before any approval is asked for, never split silently, and so is any list on a platform that does not advertise batch onboarding.
Inputs: api, repo, project, browsers, +9 more.
extension_publishA
Publish the project your stored token is scoped to (extension_auth, or EXTENSION_DEV_TOKEN) to extension.dev, and return its shareable URL. This is what "deploy" or "ship" an extension usually means; extension_submit is the separate store-review path. The target is the token's project: there is no projectPath, and no local file is uploaded. With several logins stored, pass project ('/') to pick which one; it outranks EXTENSION_DEV_TOKEN. For a public project the URL is the canonical public page and ttlHours does not apply. For a private one it is a fresh time-limited share link (?share=) whose lifetime is ttlHours.
Inputs: api, project, buildSha, ttlHours.
extension_release_promoteADestructive
Promote a built extension to a release channel (stable, preview, beta, …) on extension.dev, headless. This WRITES: it is the only verb that changes what a channel points at. It is auth-gated by your stored login (extension_auth) or a release token in EXTENSION_DEV_TOKEN, minted and revoked under project settings, Access tokens. Tokens live at most 7 days, so CI must re-mint before expiry. The project comes from the token; with several logins stored, project picks which one. Call extension_release_status to find a valid buildId. The status is 'promoted' only when the platform says every asked browser's release was dispatched and the channel pointer moved; 'promoted-partially' lists in its warnings what did not happen (a browser whose dispatch failed, a channel pointer that was not moved) and must not be repeated whole; 'promote-unconfirmed' means the platform's answer did not carry the result, so read extension_release_status before promoting again. Cutting a version-bump PR is not available headlessly, because it writes to your source repo and needs an interactive login.
Inputs: buildId (required), channel (required), api, project, +5 more.
extension_release_statusARead-onlyIdempotent
Read where a project stands on extension.dev, from the public registry (registry.extension.land). This is read-only: it dispatches nothing and promotes nothing. Pass include:'releases' for the release channels (channel to promoted build sha), recent builds, and a public build-page URL for each, which is how you find a valid sha for extension_release_promote, extension_submit or extension_publish. Pass include:'stores' for the per-store picture after an extension_submit (chrome, firefox, edge, safari): configured or not, the last credential health check, the last recorded submission, and the latest review status, read from stores/health.json, stores/status.json and stores/submissions.json. Both are included by default. This defaults to the logged-in project (extension_auth); pass workspace and project to read another. Private projects work when your stored login covers them. Registry state can lag the store dashboards by up to a polling interval.
Inputs: api, include, project, workspace.
extension_reloadAIdempotent
Reload a running extension's background context, or a tab. Start the session with allowControl:true (extension_dev).
Inputs: projectPath (required), tab, browser, context, +1 more.
extension_startA
Run the PRODUCTION build in a browser: build the project, serve it, and launch. There is no hot module replacement and no control channel, so your edits are not picked up and extension_eval, extension_storage, extension_reload, extension_open and extension_dom_snapshot cannot attach to this session. Use extension_dev while writing code, and this to check what actually ships. Pass build:false to launch an existing dist/ without rebuilding, or outputPath to launch any prebuilt unpacked extension directory, one another toolchain produced included, which implies build:false.
Inputs: projectPath (required), host, port, build, +10 more.
extension_stopADestructiveIdempotent
Stop a session that extension_dev or extension_start is running: terminate the server and the browser it launched, and remove the live-preview carrier if extension_dev placed one. This covers extension_start build:false too, which the registry records as a preview session. Call it when you are done verifying, so sessions do not accumulate.
Inputs: all, browser, projectPath, includeOtherServers.
extension_storageADestructive
Read or write chrome.storage in a running extension. Every call runs in the extension's background (the engine honours no context), so it proves nothing about what a content script or page can read. A set is read back and the answer says whether the stored value matches. Start the session with allowControl:true (extension_dev). Set one key per call: there is no bulk-object set.
Inputs: action (required), projectPath (required), key, area, +3 more.
extension_submitADestructive
Submit a built extension for store REVIEW through extension.dev, which holds your store credentials and dispatches from your project's mirror CI: the Chrome Web Store, Firefox AMO, Edge Add-ons and the App Store (Safari). This is store review only. It does not push a build to the extension.dev platform, and it does not make a shareable link: that is extension_publish, which is what "deploy" or "ship" an extension almost always means. Reach for this only when the ask is explicitly a store submission. It defaults to a dry run that dispatches nothing: the platform verifies the token and project, finds the store workflow, reads the build from its index when that index is readable, reads store health itself and adds a Safari plan verdict; this tool re-reads the per-store health rows beside it. The dry run does not run the owner gate, the approval, the build quota, the dispatch pause or the submission-mode check, which the real run does first. Pass dryRun:false to actually submit, which is irreversible: only the workspace owner who issued the token may, and it dispatches the store workflow; a Chrome or Edge store with no saved submission mode is uploaded as a draft (absent_mode: safe) and does not enter review. A real submission answers 'submitted' only when the platform recorded a submission for every store asked; 'submitted-partially' names the stores it did not record, which are the only ones to submit again; 'submit-unconfirmed' means no usable answer came back, so read extension_release_status before submitting again, because a second call submits a second time. The project comes from your token (extension_auth or EXTENSION_DEV_TOKEN; tokens live at most 7 days, so CI must re-mint from the console's Access tokens page); with several logins stored, project picks which one. Store credentials are never arguments, and no local file is uploaded. Call extension_release_status for valid shas, and, after a real submission, for the recorded outcome and review state.
Inputs: browsers (required), buildSha (required), api, dryRun, +5 more.
extension_templatesARead-onlyIdempotent
Browse the extension.dev template catalog. Pass action:'list' (the default) to search and filter it and get metadata per template. Pass action:'source' with a slug to read one template's files, for learning a pattern before building something similar. Read framework as the UI framework only, never the language: TypeScript and JavaScript templates live under slugs ('typescript', 'content-typescript'), shadcn is a React variant ('sidebar-shadcn'), and provider AIs carry the 'ai' tag ('ai-chatgpt', 'ai-claude'). Reach those through query, tags or slug.
Inputs: slug, tags, files, query, +4 more.
extension_theme_verifyARead-onlyIdempotent
Verify a Chrome theme manifest before it ships. This settles the four-leg WYSIWYG contract (app-shows == manifest-says == chrome-paints, plus chrome-accepts) as far as is possible headless: it derives every color current Chrome would paint from the manifest through the transcribed Chromium resolver, and classifies each problem as D1 fabrication, D3 parity gap, or D4 acceptance gap (keys Chrome silently discards: dead legacy, incognito, unknown, out-of-range). It verifies only, and never authors or mutates a theme. The app-rendered and real-pixel legs need a browser, so they come back as needsAttended pointing at the assert:theme and install-parity harnesses, never as passed.
Inputs: manifest, manifestPath.
extension_waitARead-onlyIdempotent
Wait for a running dev or start session to be ready. This polls the ready.json contract and reports compiled (the compiler finished), browserAttached (the runtime executor connected), and guestLoaded (the browser's own target list shows your extension). Read guestLoaded as the trustworthy load signal: it catches a silently rejected --load-extension that leaves ready.json stamped attached with empty logs. It is null when it could not be checked, for example a gecko session with no CDP port. Every result reports budgetMs and elapsedMs; on status 'timeout', call again to keep waiting on the same contract. In a noBrowser session this returns as soon as the compile lands, instead of waiting for a browser that will never attach. Ports come from the contract, so they match what the server actually bound.
Inputs: projectPath (required), browser, timeout, timeoutMs.
extension_workspace_createA
Create an extension.dev workspace that does not exist yet, without opening the console. Use it before extension_project_create when the project's workspace is not there: project creation can only target an existing workspace, and this tool is what brings one into existence. Two-phase, like login: the first call returns a code and a URL where a signed-in GitHub user approves creating exactly this workspace and becomes its owner; call again with the returned deviceCode to finish. Check ownerGithubLogin in the answer: whoever approved the code owns the workspace. The approval mints a grant that lives minutes, can only create the one named workspace, names no project, and is never stored on this machine. Then run extension_project_create against '/'.
Inputs: workspace (required), api, deviceCode, description, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 32 tools
There is heavy surface overlap between extension_build/extension_dev/extension_start/extension_preview_web and between extension_inspect/extension_dom_snapshot/extension_eval, but the descriptions explicitly delineate each (e.g. 'ONLY this tool pierces closed shadow roots', 'use extension_dom_snapshot to choose which tab'). An agent can generally pick correctly, though the sheer density of cross-references makes misselection plausible.
Every tool uses the extension_ prefix with snake_case, and most follow a predictable verb or verb_noun shape (extension_build, extension_create, extension_release_promote, extension_manifest_validate). A few noun-only names (extension_templates, extension_browsers, extension_shares) are exceptions but consistent within their purpose.
At 32 tools the set is heavy, exceeding the 25-tool 'too many' threshold, though the domain (full extension lifecycle: scaffold, build, dev, inspect, publish, store submit, auth, releases) is genuinely broad so most tools earn their place. It still leans toward being a lot of surface for an agent to navigate.
The surface covers the whole lifecycle: templating, scaffolding, build, dev/start/preview sessions, inspection, eval, storage, reload, stop, auth, workspace/project creation, publish, release promotion/status, store submission, manifest validation, diagnoses, and docs. No obvious dead ends or missing lifecycle operations.
Maintenance
Related MCP Connectors
Build, run, debug, test and ship Chrome, Firefox, Edge and Safari extensions from your AI agent.
Live browser debugging for AI assistants — DOM, console, network via MCP.
Web scraping, browser automation, screenshots and AI data extraction for AI agents via MCP.
A paid remote MCP for AI agent browser DevTools MCP, built to return verdicts, receipts, usage logs,
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to control the Google Chrome browser through a Node.js WebSocket bridge and a dedicated browser extension. It provides tools for capturing screenshots, executing JavaScript, managing tabs, and extracting page content via the MCP protocol.2-
- AlicenseNot gradedqualityCmaintenanceLets AI coding agents control and inspect a live Chrome browser via MCP, providing Chrome DevTools capabilities for automation, debugging, and performance analysis.6 npmApache 2.0
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to control and interact with a Chrome browser via MCP, providing tools for navigation, screenshots, clicking, form filling, content extraction, and tab management.1-
- FlicenseNot gradedqualityBmaintenanceExposes your Chrome/Edge browser as MCP tools for AI agents, enabling browser automation through a Chrome extension with 47 tools for navigation, interaction, page reading, and more.17 npm-