# pixelcheck [Health: Active]

**Category:** 📂 Browser Automation  
**Repository:** https://github.com/xcodethink/pixelcheck  
**GitHub Stars:** 6  
**npm Downloads (last month):** 268  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/pixelcheck

## Description
Real eyes and hands on the web for AI agents. MCP-first. Local-first. Vendor-agnostic.

## Tools
Capabilities this server exposes over MCP:

- **audit_url** — You want the full audit pipeline against one URL — agent loop, scoring, JSON + HTML report.
- **explore_url** — You want a quick autonomous run with a free-form goal; no scenario YAML needed.
- **see** — You want to look at a URL once and get back DOM summary + screenshot + console errors + an optional natural-language note. 0 LLM cost when `goal` is omitted.
- **act** — You want to drive an action sequence (click / fill / scroll / screenshot / natural-language `act` / vision `note`) and get back per-step status + final DOM + screenshot.
- **extract** — You want a typed payload back from a URL — pricing tiers, feature lists, FAQ entries — shaped exactly the way you asked for. Hand the tool a JSON Schema; get back `data` matching it plus DOM / console / screenshot.
- **judge** — You want a rubric-driven critique of one URL — aesthetic polish, dark-pattern risk, or any custom rubric. Returns per-criterion scores (0..10) + severity-graded findings with on-screen locations. 1 vision call.
- **compare** — You want an A/B comparison of two URLs against the same rubric. Default `double_blind` mode judges each side independently then synthesises a comparison (3 vision calls, free of anchoring bias). `fast` mode is 1 call (cheaper, anchored).
- **list_personas** — Discover which personas are installed in a project.
- **list_scenarios** — Discover which scenarios are installed in a project.
- **list_capabilities** — Self-describe the server: every shipped tool with kind / cacheability / static cost band / side-effects / dependency declarations, plus the public env-var table and live result-cache state. Pure introspection — call it once on first connect to plan the rest of your session.
- **calibrate_critic** — Run the critic calibration gate against labeled fixtures (returns pass/fail + agreement metrics).
- **get_last_report** — Read the most recent audit's summary JSON from the local history DB.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "pixelcheck": {
    "command": "npx",
    "args": ["-y","pixelcheck"],
    "env": {
      "ANTHROPIC_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `ANTHROPIC_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What pixelcheck MCP server does

The pixelcheck MCP server connects an MCP client to rendered web pages through a locally running Chromium browser. It gives an agent ways to inspect a page, perform browser actions, retrieve structured content, and evaluate one or two URLs against defined criteria.

The `see` tool captures a single view and can return a DOM summary, screenshot, console errors, and an optional natural-language note. Omitting the `goal` avoids LLM cost for that operation. `act` runs sequences such as clicks, form fills, scrolling, screenshots, natural-language actions, and vision notes, then reports step results and the final page state.

For data collection, `extract` accepts a JSON Schema and returns data shaped to that schema, along with page diagnostics and a screenshot. `judge` scores a URL against a custom rubric, returning criterion scores from 0 to 10 and findings with severity and on-screen locations. `compare` applies the same rubric to two URLs; its default double-blind mode evaluates each independently before synthesizing the result, while `fast` uses one vision call.

## How it works

The server exposes the browser primitives and additional workflow tools over MCP. `audit_url` runs the full audit pipeline for one URL and produces JSON and HTML reporting. `explore_url` performs an autonomous run from a free-form goal without requiring scenario YAML. The audit preset can also combine personas and scenarios for broader product reviews.

Project discovery tools include `list_personas` and `list_scenarios`. `list_capabilities` reports the available tools, their cost and cacheability information, side effects, dependencies, public environment variables, and live result-cache state. `calibrate_critic` checks the critic against labeled fixtures and returns pass/fail information with agreement metrics. `get_last_report` reads the latest audit summary from the local history database.

## Setup and configuration

Install the package globally with npm, then run the diagnostic command before starting the MCP process:

```bash
npm install -g pixelcheck
pixelcheck doctor
pixelcheck-mcp
```

The browser binary is installed during package installation. The documented MCP configuration uses the `pixelcheck-mcp` command with stdio transport. A typical client entry passes `ANTHROPIC_API_KEY` in the server environment:

```json
{
  "mcpServers": {
    "pixelcheck": {
      "command": "pixelcheck-mcp",
      "env": { "ANTHROPIC_API_KEY": "sk-ant-..." }
    }
  }
}
```

Restart the MCP client after adding the configuration. The pixelcheck MCP server is documented for Claude Desktop, Cursor, Cline, Continue, Zed, and Claude Code.

## Limitations and notes

The pixelcheck MCP server runs locally and does not use remote storage or telemetry according to the project documentation. Its stated outbound destination is the LLM provider used for agent or vision-critic work. Vision-based scoring sends audit data to Anthropic after opt-in on the first run, so teams should account for that data flow before using critic or audit features.

The repository documents Claude support today. OpenAI, Gemini, and Ollama-local provider support is described as a future roadmap item rather than a current capability. The audit preset complements traditional end-to-end tests; it is presented as a product-experience review layer, not a replacement for functional E2E coverage.

_Full upstream README: https://allmcps.com/mcp/pixelcheck/readme_