# BrowserWing: turning recorded browser actions into MCP commands and Claude Skills

> BrowserWing is a Go-based browser automation platform with a visual recorder, 78 built-in scripts and MCP and Skills protocol support. It suits teams that want AI agents to call fixed browser commands instead of driving a page token by token.

**browserwing/browserwing** — BrowserWing turns your browser actions into MCP commands Or Claude Skill, allowing AI agents to control browsers efficiently and reliably. Say goodbye to slow, token-heavy LLM interactions — let agents call commands directly for faster automation. Perfect for AI-driven tasks, browser automation, and boosting productivity.

- Repository: https://github.com/browserwing/browserwing
- Website: https://www.browserwing.com
- Stars: 1,415 · Forks: 130
- Language: Go
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/browserwing-browserwing

## The token cost of letting an LLM drive a browser directly

An agent that controls a browser by reading the DOM and deciding each click spends tokens on every step. A five-step flow becomes five rounds of page state in the context window, and the same flow run tomorrow costs the same again because nothing was saved. BrowserWing's answer is to move the browser work out of the model and into a command the model can call by name. The README frames this as letting agents "call commands directly for faster automation". The target user is someone building AI-driven tasks where the browser steps are stable and repeatable: pulling a trending list, logging into a dashboard, extracting a table. The project also ships 78 built-in scripts, so a user can get output before recording anything. If your browser task changes shape on every run, the command model buys you less.

## How BrowserWing splits recording, execution and protocol exposure

The repository is a Go backend with a React and TypeScript frontend built by Vite, wired together through a Makefile that embeds the frontend into the backend binary with the embed build tag. The backend exposes what the README calls 26+ HTTP API endpoints for browser control. A visual recorder captures browser actions, and those recordings can be exported in two directions: as MCP commands, or as Skills files. The MCP path is a server endpoint at /api/v1/mcp/message, which the README shows configured as an HTTP MCP server. The Skills path produces a SKILL.md that an AI tool imports. There is also an LLM-powered semantic extraction layer that the README says supports OpenAI, Claude and DeepSeek, plus session management for cookies and storage. The flow is therefore: record or pick a script, store it, expose it over one of the two protocols, and let the agent invoke it. Chrome or Chromium must be installed and reachable, which the README lists as the only requirement.

## Installing BrowserWing from npm and running a first built-in script

The README recommends the package manager route. The global npm install places a browserwing binary on your PATH, and the server starts on the port you pass. The npm package tests GitHub and Gitee mirrors during installation and picks the faster one, according to the README.

```bash
npm install -g browserwing
browserwing --port 8080
```

Once the server is listening, open http://localhost:8080 in a browser for the visual interface. The CLI also runs built-in scripts directly, without going through the UI. The README's own example pipes a script's JSON output into jq to take the first five entries.

```bash
browserwing run github-trending
browserwing run hackernews-top | jq '.[0:5]'
```

If you would rather have an agent do the setup, the README suggests sending it the INSTALL.md URL and letting it handle configuration, Chrome setup and Skill integration. On macOS, a "killed" error at startup is addressed in the README with a quarantine attribute removal on the binary path.

## Wiring BrowserWing into an MCP-compatible AI tool

The integration is a JSON block pasted into the AI tool's MCP settings. The README gives this exact configuration, with the server type set to http and the URL pointing at the local message endpoint.

```json
{
  "mcpServers": {
    "browserwing": {
      "type": "http",
      "url": "http://localhost:8080/api/v1/mcp/message"
    }
  }
}
```

The alternative is the Skills route: start BrowserWing, download SKILL.md from the repository, import it into the AI tool's Skills settings, and then issue natural language commands. The README notes that any scripts can be combined into a single SKILL.md, which is the interesting part. It means the unit you expose to the agent is a curated set of browser capabilities, not the whole platform. What the README does not document is how command names collide when two exported scripts target the same site, or what happens to an exported Skill when the underlying script is edited afterwards. That gap matters if you plan to keep Skills in version control alongside the scripts they came from.

## Where BrowserWing is the wrong tool

The built-in scripts are tied to specific sites, and the README presents them as ready to run without describing a maintenance process for when a site changes its markup. A recorded script is a fixed sequence of actions, so a layout change breaks it the same way it breaks any selector-based automation. If your target is one site and one extraction, a small script using a headless browser library is less machinery than a Go server with an embedded frontend, a recorder and two protocol layers. The requirement of a Chrome or Chromium binary also rules out the leanest container images unless you add one. And the LLM-powered extraction is a second dependency: it needs a provider, which means credentials and cost outside the browser stack itself. The README does not state what happens when that provider is unreachable mid-run.

## BrowserWing against Playwright and Puppeteer

Playwright and Puppeteer are libraries. You write code, you own the selectors, and the browser control lives in your process. BrowserWing inverts that: the browser control lives in a long-running server, and the caller is an AI agent speaking MCP or reading a Skill file. The practical difference shows up in who maintains the flow. With a library, a broken selector is a code change in your repository. With BrowserWing, it is an edit in the visual recorder and a re-export of the command or Skill. The second difference is the interface surface. A library gives you a programmatic API; BrowserWing gives you HTTP endpoints, a CLI, and a protocol layer designed for model consumption. If your consumer is a human developer, the library is the shorter path. If your consumer is an agent that should not be reasoning about DOM structure, the command indirection is the point.

## Maintenance, releases and what the MIT licence leaves open

The last push to the default branch was on 2026-08-08, and the repository is not archived, so the codebase has seen work within the last two months. The most recent tagged release is v1.1.1-beta.1 from 2026-05-08, preceded by v1.1.0 on 2026-04-20 and v1.0.1-beta.2 on 2026-03-06. The pattern is worth noting for anyone pinning versions: the newest tag is a beta, so the stable line available to you is v1.1.0. The Makefile carries VERSION = "v1.1.1-beta.1", which means a source build from the default branch reports the beta version. The project is MIT licensed, which permits commercial use and modification; the licence file is at the repository root. MIT says nothing about the third-party LLM providers you configure for semantic extraction, so their terms apply separately. Homebrew installation is listed as coming soon in the README, so macOS and Linux users currently have npm, the install script or a manual binary download.

## Conclusion

Adopt BrowserWing if you already have a Chrome or Chromium binary in the environment and want agent-driven browser work expressed as repeatable commands rather than free-form page interaction. Skip it if you need a single-purpose headless scraper, because you would be carrying a Go server, an embedded React frontend and a recorder you never open. Before committing, verify that the built-in script you intend to run still matches the target site, and check the licence and version of whatever LLM provider you point the semantic extraction at.

## FAQ

### What is BrowserWing used for?

It turns browser actions into commands that AI agents can call, either as MCP commands or as Skills files. The README describes it as a browser automation platform with 78 built-in scripts, a CLI, a visual recorder and LLM-powered data extraction.

### How do I install BrowserWing?

The README recommends npm install -g browserwing followed by browserwing --port 8080. There are also one-line install scripts for Linux, macOS and Windows, prebuilt binaries on the Releases page, and a source build via make build-embedded.

### Does BrowserWing need Chrome installed?

Yes. The README lists Google Chrome or Chromium installed and accessible in your environment as the only stated requirement.

### How do I connect BrowserWing to an MCP-compatible AI tool?

Add it as an HTTP MCP server pointing at http://localhost:8080/api/v1/mcp/message, using the JSON configuration the README provides for the mcpServers block. The alternative is downloading SKILL.md and importing it into the tool's Skills settings.

### What is browser automation used for?

In BrowserWing's case the README points at AI-driven tasks: agents call commands for browser steps instead of driving the page interaction by interaction, and recorded scripts can be exported for reuse. The built-in scripts cover sites such as GitHub trending, Bilibili hot and Hacker News top.

## Sources

- [browserwing/browserwing on GitHub](https://github.com/browserwing/browserwing)
- [License: MIT](https://github.com/browserwing/browserwing/blob/main/LICENSE)
- [Project website](https://www.browserwing.com)
- [README](https://github.com/browserwing/browserwing/blob/main/README.md)
- [Releases](https://github.com/browserwing/browserwing/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/browserwing-browserwing