Proporciona a los agentes de IA primitivas de navegador para ver, actuar, extraer, juzgar y comparar páginas web mediante visión y acciones semánticas.
También conocido como xcodethink/pixelcheck
- Stars
- 7
- Herramientas
- 16
- Descargas, 30 días
- —
- Última versión
- 2.1.0
- Último commit
- 12 oct 2026
- Licencia
- MIT
¿Qué es PixelCheck MCP?
PixelCheck es un MCP server. Proporciona a los agentes de IA primitivas de navegador para ver, actuar, extraer, juzgar y comparar páginas web mediante visión y acciones semánticas. Expone 16 herramientas, como audit_url, explore_url, see.
Resumen generado a partir del README del proyecto
Acerca del MCP server de PixelCheck
PixelCheck proporciona a los agentes de IA la capacidad de interactuar con navegadores web a través de cinco primitivas principales: ver, actuar, extraer, juzgar y comparar. Está diseñado para desarrolladores que quieren que sus agentes de IA hagan más que solo escribir código, permitiéndoles observar el HTML renderizado, leer errores de consola y realizar acciones semánticas. Este servidor es local-first, lo que significa que se ejecuta en tu propia máquina y mantiene privados todas las capturas de pantalla, los datos del DOM y los tokens de autenticación.
Los usuarios pueden integrar el servidor en clientes como Claude Desktop, Cursor, Cline o Zed añadiéndolo a sus archivos de configuración. Aunque actualmente utiliza Anthropic para el juicio basado en visión, la arquitectura es agnóstica al proveedor. La herramienta también incluye un audit preset que simula dieciocho personas diferentes en quince países para probar la localización, la accesibilidad y la experiencia de usuario. Esto ayuda a detectar problemas como diseños RTL rotos o cadenas de texto no traducidas que las pruebas end-to-end tradicionales suelen pasar por alto.
Qué puedes hacer con él
- 1Verificar el renderizado del frontendPide a un agente de IA que compruebe si un botón o componente de UI recién escrito se renderiza correctamente en un navegador real.
- 2Extraer datos web estructuradosInstruye a un agente para que extraiga información específica de un sitio web utilizando un esquema JSON o Zod predefinido.
- 3Realizar auditorías de UXHaz que un agente califique una página web según una rúbrica específica para identificar dark patterns o problemas de usabilidad.
- 4Probar la localización globalEjecuta una auditoría automatizada para asegurar que tu aplicación se visualice correctamente para usuarios en diferentes países e idiomas.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Cómo instalar PixelCheck MCP
Formatos verificados el 10 nov 2026Añadir a CursorAñadir a GooseInstalar PixelCheck MCP en Claude Code
$ claude mcp add --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' pixelcheck -- npx -y pixelcheckInstalar PixelCheck MCP en Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"pixelcheck": {
"command": "npx",
"args": [
"-y",
"pixelcheck"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>"
}
}
}
}Instalar PixelCheck MCP en VS Code
.vscode/mcp.json
{
"servers": {
"pixelcheck": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"pixelcheck"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>"
}
}
}
}Instalar PixelCheck MCP en VS Code CLI
$ code --add-mcp '{"name":"pixelcheck","type":"stdio","command":"npx","args":["-y","pixelcheck"],"env":{"ANTHROPIC_API_KEY":"<YOUR_ANTHROPIC_API_KEY>"}}'Instalar PixelCheck MCP en Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"pixelcheck": {
"command": "npx",
"args": [
"-y",
"pixelcheck"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>"
}
}
}
}Instalar PixelCheck MCP en Codex
$ codex mcp add pixelcheck --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' -- npx -y pixelcheckInstalar PixelCheck MCP en Codex config.toml
~/.codex/config.toml
[mcp_servers.pixelcheck] command = "npx" args = ["-y", "pixelcheck"] [mcp_servers.pixelcheck.env] ANTHROPIC_API_KEY = "<YOUR_ANTHROPIC_API_KEY>"
Instalar PixelCheck MCP en Gemini CLI
$ gemini mcp add -s user -e 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' pixelcheck npx -- -y pixelcheckInstalar PixelCheck MCP en Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"pixelcheck": {
"command": "npx",
"args": [
"-y",
"pixelcheck"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>"
}
}
}
}Herramientas de PixelCheck MCP 16
Detectado desde el READMEaudit_urlexplore_urlseeactextractjudgecomparelist_personaslist_scenarioslist_capabilitiescalibrate_criticget_last_report
| audit_url | — | |
| explore_url | — | |
| see | — | |
| act | — | |
| extract | — | |
| judge | — | |
| compare | — | |
| list_personas | — | |
| list_scenarios | — | |
| list_capabilities | — | |
| calibrate_critic | — | |
| get_last_report | — |
Mostrar las 16 herramientasMostrar menos herramientas
gotoscreenshotnotecustom
| goto | — | |
| screenshot | — | |
| note | — | |
| custom | — |
Configuración
ANTHROPIC_API_KEYObligatorioSecretoAnthropic API key. Required for LLM-backed primitives (judge, extract-with-schema) and the audit_url / explore_url presets. Meta tools (list_personas, list_scenarios, get_last_report) work without it.
LOG_LEVELLOG_PRETTY
| Nombre | Descripción | Tipo |
|---|---|---|
| ANTHROPIC_API_KEY | Anthropic API key. Required for LLM-backed primitives (judge, extract-with-schema) and the audit_url / explore_url presets. Meta tools (list_personas, list_scenarios, get_last_report) work without it. | ObligatorioSecreto |
| LOG_LEVEL | — | |
| LOG_PRETTY | — |
Verificaciones automáticas
Ejecutado 13 nov 2026Informe completo →Pasó nuestras verificaciones automáticas. Esto no es una auditoría de seguridad: lee el código y dale al servidor el acceso más limitado que necesite. Cómo funcionan las verificaciones
- Repositorio de origen vinculado y accesibleAprobado
- Licencia de código abierto (OSI)Aprobado
- Commit o lanzamiento en el último añoAprobado
- El nombre del paquete no es similar a un paquete popularAprobado
- El endpoint remoto usa HTTPSNo verificado
- Las herramientas destructivas están etiquetadasAprobado
- Sin instrucciones ocultas para el modeloAprobado
- No hay avisos críticos en el paquete ni en sus dependenciasAprobado
README
Ver en GitHubIf PixelCheck helps you, give it a star — it helps others discover the project.
Right now, you're a screenshotting middleman.
Your AI agent is writing 80% of your frontend. It's fast. It's good at code. But it's blind.
- It writes a button. You open Chrome to check it rendered right. Paste a screenshot back. Ask for the fix.
- It tweaks the OAuth flow. You log in to verify it didn't silently break. Again. Sixth time this month.
- It updates the Japanese strings. A user emails: "half the page is in English." You didn't catch it.
- It rewrites checkout. You walk through it on iPhone, Android, iPad just to feel whether step 3 is confusing.
- It changes the Arabic layout. RTL didn't propagate. You don't notice for two days.
You become the bridge. The agent has thoughts. You have a browser. The two never meet. Hours of your week, every week, indefinitely.
PixelCheck is the bridge.
A single MCP server. Five primitives. Drop it in once — your agent has eyes and hands.
see(url, opts) snapshot a page (DOM + screenshot + console + network)
act(url, steps) execute an action sequence (semantic + selector + Computer Use)
extract(url, schema) pull structured data matching a Zod / JSON schema
judge(url, rubric) score a page against a rubric ("is this dark-pattern free?")
compare(a, b, criteria) A/B comparison of two URLs (incl. blind mode)
Now your agent navigates. Sees rendered HTML. Reads console errors. Clicks. Fills. Judges. Compares. Without ever leaving its workflow — drop into Claude Desktop, Cursor, Cline, Continue, Zed, or Claude Code via four lines in ~/.mcp.json.
npm install -g pixelcheck # browser binary auto-installs on install
pixelcheck doctor # verify environment (--fix self-heals)
pixelcheck-mcp # MCP server (stdio transport)
// ~/.mcp.json
{
"mcpServers": {
"pixelcheck": {
"command": "pixelcheck-mcp",
"env": { "ANTHROPIC_API_KEY": "sk-ant-..." }
}
}
}
Restart your client. Your agent has eyes.
Three promises that aren't going anywhere.
Local-first. PixelCheck runs entirely on your machine. The only outbound network destination is the LLM provider your agent already uses. Screenshots, DOMs, business flows, OAuth tokens, customer URLs — they stay yours. Zero telemetry. Zero remote storage. Zero SaaS sign-up. The audit data hits Anthropic only when the vision critic actively scores a screenshot, and you opt in once on first run.
Vendor-agnostic. Works with Claude today; multi-provider abstraction (OpenAI, Gemini, Ollama-local) is on the v1.x roadmap and your agent will switch with one config flag. The reason is simple: AI tools that lock you to a single LLM provider die in 2026. PixelCheck is the antidote.
Yours to own. MIT license. Source-available. No paid tier. No "Pro" upgrade path. No commercial fork waiting in the wings. The 1858-test, 29-ADR, 30-published-schema product in this repo is the entire product. There's no premium edition behind a sign-up wall — never was, never will be.
The Audit Preset — when you want to be the user, not the bridge
The five primitives compose into something more powerful when you're the operator: PixelCheck bundles an 18-persona / 15-country audit preset on top of the primitives — a CLI-first composition that runs "eighteen real users review your product" after every deployment.
You deploy. Tests pass. CI is green. But then:
- A Japanese user opens your app and sees half-translated English strings mixed into the UI
- A user on a budget Android phone in Nigeria waits 12 seconds for your hero image to load
- Your OAuth login flow silently breaks — again — for the 6th time in 10 deployments
- The Arabic version renders left-to-right, making the entire layout unusable
- Your "Trusted" score badge shows green while the copy says "stop interacting immediately"
No E2E test catches these. They test whether code runs. They don't test whether the product works for real humans in real contexts.
The audit preset launches real Chromium browsers as 18 different users from 17 countries, walks through your product's core flows, and delivers a verdict — like having a senior PM, QA engineer, and UX reviewer audit every deployment, in every language, on every device class.
pixelcheck init projects/my-app --name "My App" --url "https://myapp.com"
pixelcheck run --project projects/my-app
Output: a structured report with per-step screenshots, video recordings, network logs, WCAG accessibility violations, and AI-scored ratings across 6 dimensions — served as JSON, HTML dashboard, or Markdown.
How It Works
For each (persona x scenario) combination:
1. Launch Chromium with device-accurate fingerprint
(viewport, locale, timezone, UA, regional proxy)
|
2. Execute scenario steps semantically via Stagehand 3.x
("click the sign-up button" not "click #btn-37")
|
3. 5-Layer Reliability Stack ensures 98%+ step success
Stability Gate -> LLM Rewrite -> Selector Discovery -> Auto Selector -> Computer Use
|
4. Claude Vision Critic + axe-core score each checkpoint on 18 dimensions
completion | localization | visual_polish | trust_signals | accessibility | ...
|
5. Critical steps escalate to Computer Use for pixel-level review
|
6. Generate report: JSON + HTML dashboard + Markdown + video + HAR
Why Not E2E Tests?
| Traditional E2E | PixelCheck (audit preset) | |
|---|---|---|
| What it tests | Code logic | Product experience |
| Decision making | Hardcoded selectors | AI reads the page like a human |
| Assertion style | expect(text).toBe("Welcome") |
"As a Japanese free-tier user, is this CTA clear and fully localized?" |
| When UI changes | Selectors break, tests fail | Semantic instructions adapt automatically |
| Failure output | Stack trace | Screenshots + video + 6-dimension score + specific UX issues |
| What it catches | Functional bugs | i18n gaps, UX friction, visual regressions, trust issues, accessibility violations, cultural mismatches |
PixelCheck's audit preset is not a replacement for E2E tests. It's what runs after them — the layer between "code works" and "product is good."
Compared to existing tools
| PixelCheck | Playwright | Cypress | Stagehand | Browserbase | |
|---|---|---|---|---|---|
| MCP server out of the box | ✅ | ❌ | ❌ | ❌ | ❌ |
| Browser primitives an AI agent can call | 5 (see / act / extract / judge / compare) | n/a (low-level page API) | n/a | 3 (act / extract / observe) | n/a |
| AI vision (judge / critique) | ✅ via Anthropic | ❌ | ❌ | ❌ (action-only) | ❌ |
| Built-in personas | 18 across 15 countries | ❌ | ❌ | ❌ | ❌ |
| Localised report (5 languages) | ✅ | ❌ | ❌ | ❌ | ❌ |
| WCAG 2.x audit + SARIF export | ✅ (axe-core + GitHub Code Scanning ready) | manual via plugins | manual via plugins | ❌ | ❌ |
| Local-first by default | ✅ (your machine, your API key) | ✅ | ✅ | ✅ (or Browserbase) | ❌ (cloud-only) |
| Vendor lock-in | none (MIT, no SaaS) | none | none | optional Browserbase | full (paid SaaS) |
| LLM provider | swap any (Anthropic default; primitives are vendor-agnostic) | n/a | n/a | swap any | n/a |
| Open source | ✅ MIT | ✅ Apache 2.0 | ✅ MIT | ✅ MIT | partial |
TL;DR: Playwright / Cypress are deterministic browser drivers — you tell them exactly what to click. Stagehand wraps Playwright with natural-language act / extract so an agent can drive a browser. PixelCheck is the next layer up: an MCP-shaped surface that gives any AI agent vision (see / judge / compare) on top of action (act / extract), with audit presets composed across personas. Use Playwright for unit-style tests; use Stagehand if you only need an agent to fill forms; use PixelCheck when the agent needs to evaluate a UI, not just operate it.
Personas
18 built-in personas covering real-world user diversity. The Subscriber Tier column is the persona's subscription level in the SaaS you're auditing (Free user / Pro subscriber / Power-user / enterprise) — used so PixelCheck can audit your product's tiered features (paywalls, upsells, gated UI, Pro-only flows). PixelCheck itself is MIT-licensed and 100% free with no paid tier or commercial fork.
| Persona | Country | Language | Device | Subscriber Tier (in your app) |
|---|---|---|---|---|
| US college student | US | English | iPhone 14 | Free |
| Tokyo housewife | JP | Japanese | MacBook Pro | Pro |
| Berlin security analyst | DE | German | iPad Pro | Power |
| Shanghai student | CN | Chinese | Xiaomi Android | Free |
| Sao Paulo freelancer | BR | Portuguese | Desktop | Free |
| Riyadh businessman | SA | Arabic (RTL) | iPhone 15 Pro | Pro |
| Mumbai office worker | IN | Hindi | Budget Android | Free |
| Seoul designer | KR | Korean | QHD Desktop | Pro |
| Hanoi student | VN | Vietnamese | Android | Free |
| Moscow engineer | RU | Russian (Cyrillic) | Windows Desktop | Free |
| Lagos entrepreneur | NG | English | Budget Tecno | Free |
| Mexico City teacher | MX | Spanish (LATAM) | Android | Free |
| Jakarta gig worker | ID | Bahasa Indonesia | Android | Free |
| US retired teacher (72yo) | US | English | iPad | Free |
| London security analyst | UK | English | Desktop | Power |
| Paris marketing manager | FR | French | iPhone | Free |
| Bangkok student | TH | Thai | iPhone SE | Free |
| Taipei engineer | TW | Traditional Chinese | iPad | Pro |
Each persona includes a mental model (who they are, what they expect) and critical concerns (what would make them lose trust). The AI reviewer judges your product through their eyes.
6 script systems: Latin, CJK, Arabic (RTL), Cyrillic, Devanagari, Thai.
Scenarios Are Declarative YAML
No code required. Describe what a user does, not how to click:
id: signup-flow
name: New User Signup
priority: P0
steps:
- id: open-home
type: visit
url: https://myapp.com/${persona.url_locale}
- id: click-signup
type: act
instruction: Click the sign-up or get-started button
- id: check-language
type: assert_visual
instruction: |
Is all visible text in ${persona.language}?
Flag any English strings outside of brand names.
- id: complete-oauth
type: act
instruction: Sign in with Google
- id: verify-email
type: check_email
subject_contains: "welcome"
timeout: 60000
- id: a11y-check
type: assert_a11y
standard: wcag2aa # axe-core WCAG analysis
exclude: [".cookie-banner"]
- id: rate-onboarding
type: assert_visual
critical_review: true # escalates to Computer Use
instruction: |
Rate the post-signup experience. Is the value proposition
clear within 10 seconds? Is the first action obvious?
12 step types: visit, act, extract, observe, wait_for, assert_visual, assert_dom, assert_a11y, check_email, screenshot, computer_use, custom
5-Layer Reliability Stack
AI-driven browsers are flaky (~75% baseline). We engineered that away:
Layer 1: Page Stability Gate +10% (zero cost)
Wait for network idle + DOM stable + framework hydration
|
Layer 2: LLM Rewrite + Local Mutation +7% (~$0.001/call)
Haiku rewrites failed instructions using DOM context;
local rules rephrase/decompose/specify as fallback
|
Layer 3a: Selector Hint +3% (zero cost)
Optional CSS selector fallback (manual or YAML-defined)
|
Layer 3b: Auto Selector Discovery +3% (zero cost)
Stagehand observe() extracts candidate selectors automatically
|
Layer 4: Computer Use Fallback +2-4% ($0.01-0.15/call)
Claude sees the actual pixels and operates the browser directly
(Sonnet for non-critical steps, Opus for critical reviews)
Target: 98-99% step success rate across all persona/scenario combinations.
Each step records which layer succeeded via execution_method, giving you a reliability breakdown per run.
Reports
Every audit produces a full evidence package:
reports/2026-04-11_post-deploy/
|-- audit.json # Machine-readable, all scores and issues
|-- audit.html # Dark-theme dashboard with trend sparklines
|-- audit-explorer.html # Filterable SPA view of every (scenario × persona) — open with ?lang=zh-CN/ja/es/de for localised UI chrome
|-- audit.pdf # Stakeholder-facing summary (A4, 12pt, vector text)
|-- summary.md # Terminal-friendly overview
|-- jp-japanese-pro-desktop__signup-flow/
|-- 01-open_home.png # Timestamped screenshot
|-- 02-check_language.png # + SHA-256 hash for each
|-- network.har # Full network log
|-- console.log # Browser console errors
|-- video/*.webm # Session recording
audit.json and every MCP tool response carries a top-level schema_version field (SemVer). The contract is documented in docs/contracts/RESULT_SCHEMA.md; machine-readable JSON Schemas live in docs/schemas/ and can be regenerated with npm run schemas.
WCAG compliance reporting
The assert_a11y scenario step runs axe-core to detect accessibility violations. As of v1, every violation carries structured WCAG attribution that flows through to all stakeholder reports:
- PDF report — a "WCAG Compliance Summary" section grouped by conformance level (A / AA / AAA), by the four WCAG principles (Perceivable / Operable / Understandable / Robust), and a top-violated-criteria table with deep links to the W3C Understanding documents.
- SARIF (GitHub Code Scanning / GitLab SAST) — per-criterion ruleIds like
wcag/1-4-3,wcag/2-1-1. Filter by W3C clause directly in the Security tab. Each rule's detail panel shows "WCAG 1.4.3 Contrast (Minimum) (Level AA)" with a link to the W3C spec. - audit.json — every accessibility issue gets
wcag_levelandwcag_criterionfields alongside the existingdescription/recommendation.
Catalog covers WCAG 2.1 (the production-deployed standard) plus the 9 net-new success criteria added in WCAG 2.2 (e.g. 2.4.11 Focus Not Obscured, 2.5.8 Target Size). Compliance teams reading reports in zh-CN / ja / es / de see the section headings translated; SC names and id numbers (1.4.3, 2.1.1) stay canonical for compliance-document consistency.
Use case — answering an RFP that asks "Are you WCAG 2.1 AA compliant?":
pixelcheck run --project myapp # writes audit.pdf + audit.sarif
# Open audit.pdf → "WCAG Compliance Summary" section shows A / AA / AAA counts
# Or upload audit.sarif via github/codeql-action/upload-sarif → grouped under wcag/* ruleIds
See ADR-024 for the full design.
Localised reports
Stakeholder reports (PDF / trends dashboard / PR diff Markdown / PR diff HTML) emit in the language of your audience. v1 supports 5 locales:
| Code | Language | Used for |
|---|---|---|
en |
English (default) | Baseline |
zh-CN |
Simplified Chinese | China-market teams |
ja |
Japanese | Japan-market product orgs |
es |
Spanish | Spain + Latin America |
de |
German | DACH-region enterprises |
pixelcheck run --project myapp --locale ja # Japanese PDF + reports
pixelcheck trends --project myapp --locale zh-CN # Chinese trends dashboard
pixelcheck diff <a> <b> --format markdown --locale es # Spanish PR comment
Or pin a default in config.yaml:
project_name: myapp
base_url: https://myapp.com
default_locale: ja # any audit run on this project defaults to ja
What's translated: report skeleton — section titles, table headers, status / severity badges, disclaimer prose. What's NOT translated: PixelCheck's findings themselves (those come from the LLM in whatever language you asked Claude for) and numeric values / dates / run IDs. See ADR-023 for the full design.
Translations reviewed by: machine-assisted draft pending native-speaker review. We track reviewer credits publicly — see docs/translation-review-template.md and the translation-review issue template. Confirmed reviewers will be listed below as the v1.x review pass completes.
| Locale | Reviewer | Date | Corrections applied |
|---|---|---|---|
en |
(source — no review needed) | — | — |
zh-CN |
pending | pending | pending |
ja |
pending | pending | pending |
es |
pending | pending | pending |
de |
pending | pending | pending |
PDF report (audit.pdf)
A 4-section A4 portrait PDF aimed at the layer of decision-makers above engineering — PMs, executives, customers, sales / CS reps. The format every email client renders inline, every slide deck embeds, every phone opens.
| Section | Contents |
|---|---|
| Cover | Project + URL + run date + colour-coded overall score (green ≥ 8, amber 5–8, red < 5) + 7-counter summary card |
| Top findings | Severity-sorted (critical → high → medium → low), capped at 5; each cites scenario × persona context + recommendation |
| Scenario results | One block per (scenario × persona): status badge, score + cost, per-dimension table, all issues |
| Methodology | How the audit works, persona list, scenario list, calibration disclaimer, run id for archival |
Vector text (selectable / searchable / accessible) — not a screenshot of HTML. No screenshots embedded so the file stays under ~1 MB and emailable; for visual evidence, the recipient opens audit-explorer.html (cited in the methodology disclaimer).
Default: ON every run. Pass --no-pdf to skip during fast local iteration. See ADR-020 for the full design.
Historical Trends
Scores are tracked in a local SQLite database. Three ways to look at history:
pixelcheck history # Terminal table of recent runs with scores
pixelcheck diff run_0412 run_0411 # Score deltas, new/resolved issues
pixelcheck trends # Full HTML dashboard with 5 charts (writes <reports>/trends.html)
pixelcheck trends reads <reports>/history.db and writes a standalone HTML dashboard answering "did our UX get better or worse?" Five inline-SVG charts (no Chart.js / external CDN — opens behind any firewall, emails / prints / archives cleanly):
| Chart | Answer it gives |
|---|---|
| Overall score line | Trending up or down? |
| Pass / Warn / Fail stacked bars | Consistent or flaky? |
| Issues over time (total + critical) | Where are the regression hot spots? |
| Cost over time | Is efficiency drifting? |
| Per-dimension multi-line | Which scoring dimension is the cause? |
Plus six summary cards at the top (latest score, mean last 7, mean last 30, total cost, total issues, total critical issues) and a recent-runs table for navigation. See ADR-021 for the full design.
pixelcheck trends --project myapp -n 90 --dashboard reports/trends.html
The per-run audit.html also includes inline sparkline charts for at-a-glance trends within that single report.
Quality Gate
Fail your CI build if the experience drops below your bar:
pixelcheck run --project projects/my-app --min-score 7.5
# Exit code 1 if overall score < 7.5
Quick Start
1. Install
npm install pixelcheck
The browser binary pixelcheck needs (Chrome Headless Shell) is fetched
automatically by a postinstall step. If that was skipped — CI,
--ignore-scripts, an offline box, or PIXELCHECK_SKIP_BROWSER_DOWNLOAD=1 —
fetch it on demand with:
npx pixelcheck install # headless audits (default)
npx pixelcheck install --headed # also fetch full Chromium for --headed runs
You never need a bare npx playwright install — pixelcheck installs the exact
browser revision it launches (a bare install can pull a mismatched revision).
A missing browser also self-heals on the first run/explore, and
pixelcheck doctor --fix downloads it directly.
For corporate proxy / Alpine Linux / Docker / air-gapped environments, see docs/INSTALLATION.md.
2. Verify your environment
npx pixelcheck doctor
Reports Node version, API key, config / scenarios / personas, network proxy, and api.anthropic.com reachability. Exits 0 when ready, 1 when any check fails — useful in CI scripts to fail-fast before running an audit.
Add --verbose for diagnostic detail, --skip-network for offline /
air-gapped environments.
3. Set up a project (interactive or scripted)
Interactive wizard (recommended for first-time users):
npx pixelcheck init
# Walks you through project name, base URL, sample scenario, and runs
Preguntas sobre PixelCheck MCP
¿Cómo agrego PixelCheck MCP a Claude Code?
Ejecuta claude mcp add --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' pixelcheck -- npx -y pixelcheck en tu terminal. Añade --scope user para que esté disponible en todos los proyectos.
¿Cómo agrego PixelCheck MCP a Cursor?
Abre ~/.cursor/mcp.json y añade el servidor en mcpServers, usando la configuración de Cursor que se muestra en la sección de instalación de arriba.
¿Qué herramientas proporciona PixelCheck MCP?
Expone 16 herramientas, incluidas audit_url, explore_url, see, act, extract.
¿Mis datos se mantienen privados?
Sí, PixelCheck es local-first y se ejecuta completamente en tu máquina sin telemetría ni almacenamiento remoto.
¿PixelCheck reemplaza las pruebas E2E?
No, está diseñado para ejecutarse después de las pruebas E2E para evaluar la experiencia del producto, la UX y la localización, en lugar de solo la lógica del código.
¿Qué es el Audit Preset?
Es una composición orientada a CLI que utiliza 18 personas en 15 países para revisar tu producto como si fueran usuarios reales.