Bietet KI-Agenten Browser-Primitives, um Webseiten mittels Vision und semantischen Aktionen zu sehen, zu steuern, zu extrahieren, zu bewerten und zu vergleichen.
Auch bekannt als xcodethink/pixelcheck
- Stars
- 7
- Tools
- 16
- Downloads, 30 Tage
- —
- Neueste Version
- 2.1.0
- Letzter Commit
- 12. Okt. 2026
- Lizenz
- MIT
Was ist PixelCheck MCP?
PixelCheck ist ein MCP server. Bietet KI-Agenten Browser-Primitives, um Webseiten mittels Vision und semantischen Aktionen zu sehen, zu steuern, zu extrahieren, zu bewerten und zu vergleichen. Er stellt 16 Tools bereit, etwa audit_url, explore_url, see.
Zusammenfassung generiert aus dem README des Projekts
Über PixelCheck MCP server
PixelCheck gibt KI-Agenten die Fähigkeit, über fünf Kern-Primitives mit Webbrowsern zu interagieren: see, act, extract, judge und compare. Es ist für Entwickler gedacht, die von ihren KI-Agenten mehr wollen als nur Code zu schreiben – es ermöglicht ihnen, gerendertes HTML tatsächlich zu beobachten, Console-Errors zu lesen und semantische Aktionen auszuführen. Dieser Server ist local-first, was bedeutet, dass er auf deiner eigenen Maschine läuft und alle Screenshots, DOM-Daten und Authentication-Tokens privat hält.
Nutzer können den Server in Clients wie Claude Desktop, Cursor, Cline oder Zed integrieren, indem sie ihn zu ihren Config-Dateien hinzufügen. Während er aktuell Anthropic für das vision-basierte Judging nutzt, ist die Architektur herstellerunabhängig. Das Tool enthält außerdem ein Audit Preset, das achtzehn verschiedene Personas in fünfzehn Ländern simuliert, um Lokalisierung, Accessibility und User Experience zu testen. Dies hilft dabei, Probleme wie fehlerhafte RTL-Layouts oder nicht übersetzte Strings zu finden, die herkömmliche End-to-End-Tests oft übersehen.
Was du damit machen kannst
- 1Frontend-Rendering verifizierenLass einen KI-Agenten prüfen, ob ein neu geschriebener Button oder eine UI-Komponente in einem echten Browser korrekt gerendert wird.
- 2Strukturierte Webdaten extrahierenWeise einen Agenten an, spezifische Informationen von einer Webseite unter Verwendung eines vordefinierten JSON- oder Zod-Schemas zu ziehen.
- 3UX-Audits durchführenLass einen Agenten eine Webseite anhand einer spezifischen Rubrik bewerten, um Dark Patterns oder Usability-Probleme zu identifizieren.
- 4Globale Lokalisierung testenFühre ein automatisiertes Audit durch, um sicherzustellen, dass deine Anwendung für Nutzer in verschiedenen Ländern und Sprachen korrekt angezeigt wird.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du PixelCheck MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenPixelCheck MCP in Claude Code installieren
$ claude mcp add --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' pixelcheck -- npx -y pixelcheckPixelCheck MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"pixelcheck": {
"command": "npx",
"args": [
"-y",
"pixelcheck"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>"
}
}
}
}PixelCheck MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"pixelcheck": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"pixelcheck"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>"
}
}
}
}PixelCheck MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"pixelcheck","type":"stdio","command":"npx","args":["-y","pixelcheck"],"env":{"ANTHROPIC_API_KEY":"<YOUR_ANTHROPIC_API_KEY>"}}'PixelCheck MCP in Claude Desktop installieren
claude_desktop_config.json
{
"mcpServers": {
"pixelcheck": {
"command": "npx",
"args": [
"-y",
"pixelcheck"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>"
}
}
}
}PixelCheck MCP in Codex installieren
$ codex mcp add pixelcheck --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' -- npx -y pixelcheckPixelCheck MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.pixelcheck] command = "npx" args = ["-y", "pixelcheck"] [mcp_servers.pixelcheck.env] ANTHROPIC_API_KEY = "<YOUR_ANTHROPIC_API_KEY>"
PixelCheck MCP in Gemini CLI installieren
$ gemini mcp add -s user -e 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' pixelcheck npx -- -y pixelcheckPixelCheck MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"pixelcheck": {
"command": "npx",
"args": [
"-y",
"pixelcheck"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>"
}
}
}
}PixelCheck MCP tools 16
Erkannt aus dem 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 | — |
Alle 16 Tools anzeigenWeniger Tools anzeigen
gotoscreenshotnotecustom
| goto | — | |
| screenshot | — | |
| note | — | |
| custom | — |
Konfiguration
ANTHROPIC_API_KEYErforderlichSecretAnthropic 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
| Name | Beschreibung | Typ |
|---|---|---|
| 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. | ErforderlichSecret |
| LOG_LEVEL | — | |
| LOG_PRETTY | — |
Automatisierte Checks
Geluften am 13. Nov. 2026Vollständiger Bericht →Unsere automatisierten Checks bestanden. Das ist kein Security-Audit: Lies den Code und gib dem Server nur den minimal notwendigen Zugriff. Wie die Checks funktionieren
- Source Repository verknüpft und erreichbarBestanden
- Open Source Lizenz (OSI)Bestanden
- Commit oder Release im letzten JahrBestanden
- Package-Name ähnelt keinem populären PackageBestanden
- Remote Endpoint nutzt HTTPSNicht geprüft
- Destruktive Tools sind markiertBestanden
- Keine versteckten Anweisungen an das ModellBestanden
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenBestanden
README
Auf GitHub ansehenIf 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
PixelCheck MCP Fragen
Wie füge ich PixelCheck MCP zu Claude Code hinzu?
Führe claude mcp add --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' pixelcheck -- npx -y pixelcheck in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich PixelCheck MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Welche Tools bietet PixelCheck MCP?
Er stellt 16 Tools bereit, darunter audit_url, explore_url, see, act, extract.
Bleiben meine Daten privat?
Ja, PixelCheck ist local-first und läuft vollständig auf deiner Maschine, ohne Telemetrie oder Remote-Speicherung.
Ersetzt PixelCheck E2E-Tests?
Nein, es ist dafür konzipiert, nach E2E-Tests zu laufen, um das Produkt-Erlebnis, die UX und die Lokalisierung zu bewerten, anstatt nur die Code-Logik zu prüfen.
Was ist das Audit Preset?
Es ist eine CLI-fokussierte Komposition, die 18 Personas in 15 Ländern nutzt, um dein Produkt wie echte Nutzer zu testen.