Webability

WebAbility MCP

Accessibility checks your coding agent can act on: scan a page with two engines, get a structured fix for each issue, then re-check that the fix landed.

Free. Hosted at https://mcp.webability.io/mcp. No API key for scans. MIT.

Install

Claude Code (plugin)

/plugin marketplace add snayyar00/webability-mcp

/plugin install webability-accessibility@webability

or claude mcp add --transport http webability https://mcp.webability.io/mcp

Cursor: Add to Cursor

VS Code: Install in VS Code · or run code --add-mcp '{"name":"webability","type":"http","url":"https://mcp.webability.io/mcp"}'

Claude.ai / ChatGPT / any MCP client: add a custom connector with the URL https://mcp.webability.io/mcp.

Local (the browser runs on your machine, so it scans localhost directly): npx -y -p @webability/mcp webability-mcp

What you get back

Real output, scan_page on https://demo.vercel.store (trimmed):

Found 16 high-confidence issue(s): 0 critical, 4 serious, 8 moderate, 4 minor.

20 additional finding(s) need human review — see incomplete[]. Do NOT auto-fix these.

missing_label · serious · WCAG 1.3.1 · input.text-md.w-full.rounded-lg fix: { op: "add-attribute", attribute: "aria-label" } fixability: contextual missing_table_scope · moderate · WCAG 1.3.1 · thead > tr > th:nth-of-type(1) (vite.dev/guide) fix: { op: "add-attribute", attribute: "scope", value: "col" } fixability: mechanical

verify_fix input.text-md.w-full.rounded-lg wcag=4.1.2 NOT RESOLVED: 1 violation still present → "verified": false

• `fix.op` is one of add-attribute, set-attribute, remove-attribute, add-element, remove-element, add-text-content, suggest.
• `fixability`: mechanical = apply as given. contextual = the op is known, the value (alt text, a label) needs judgment. visual = needs rendered output; propose, do not auto-apply.
• `judged[]` lists findings the scanner settled itself, each with a verdict and a reason (see Output below). Anything it cannot settle is dropped.
• `source`: on React ≤18 and Vue dev builds, each issue carries {file, line, column, component} from the live component tree.
• `verify_fix` re-scans one element and fails closed. `diff_scan` reports fixed[], new[], remaining[] for a page.

Free

No trial, no credits, no paid tier on the MCP.

What it does not do

It cannot judge if alt text is meaningful or if a custom widget makes sense with a screen reader. Use it to clear the automated layer in source, then test with assistive technology.

Local vs hosted

Scanning a local dev server

Use Lite (stdio). It runs the browser on your machine, so http://localhost:3000 is just localhost:

claude mcp add webability-local -- npx -y -p @webability/mcp webability-mcp

Other clients: add npx -y -p @webability/mcp webability-mcp as a stdio server.

Full (hosted) cannot reach your machine directly, by design. It runs in our cloud, so localhost there means *our* localhost. Every URL is checked before any fetch and loopback / private / link-local addresses are refused: without that check, anyone could point the server at internal services or a cloud metadata endpoint. That check is not relaxed for anyone.

When you need hosted: webability-tunnel

CI, a remote agent, or a dashboard-triggered scan cannot run Lite, because there is no laptop in the loop. For those, open a tunnel:

WEBABILITY_API_KEY=<your-token> npx -y -p @webability/mcp webability-tunnel --port 3000

It prints a https://tunnel.webability.io/t/ / URL and a secret. Pass the URL as url and the secret as tunnel_secret:

"Scan https://tunnel.webability.io/t/abc123.../ with tunnel_secret <secret>"

Your machine dials out to the relay, so the URL is an ordinary public hostname and the SSRF check above still applies unchanged — nothing is weakened to make this work. Same idea as ngrok, with three differences that matter when the thing on the far side is your dev machine:

• The URL is not a credential. Every request must carry the secret header; the URL alone returns 401. URLs leak into shell history, CI logs and screenshots.
• Only `GET` and `HEAD` reach you, on the one port you named, and Authorization / Cookie are stripped before anything crosses in.
• It dies when you do. 30 minutes, 5 minutes idle, or the moment you press Ctrl-C.

Anyone holding both the URL and the secret can read your dev server. Treat the pair like a password, and prefer Lite whenever there is a human at a keyboard.

Third-party tunnels (ngrok, cloudflared) also work — the hosted scanner treats their hostnames like any other public site — but they expose your dev server to anyone who learns the URL. Vite users, either way: add the tunnel hostname to server.allowedHosts, or it answers 403 Blocked request to everything.

start_audit is the exception on both transports — its pipeline runs on our servers even under Lite, so it can never reach a localhost URL.

Local options

Optional env:

• WEBABILITY_API_URL (default https://api.webability.io) for self-hosted backends.
• POSTHOG_PROJECT_API_KEY or POSTHOG_API_KEY to enable PostHog MCP Analytics for MCP initialize, tools/list, and tool-call usage events.
• POSTHOG_HOST (default https://us.i.posthog.com) for EU or self-hosted PostHog ingestion.
• WEBABILITY_POSTHOG_MCP_ANALYTICS=off to force-disable PostHog MCP Analytics even when a PostHog key is present.

Scan engines

scan_page runs two engines in parallel and deduplicates the results:

Output

Every scan returns:

• `issues` — violations the scanner stands behind, safe to surface as bugs
• `summary` — counts by severity

The scanner judges uncertain findings itself. Text on a gradient or image background is measured from rendered pixels. What the engines still cannot decide goes to an AI judge, which returns a violation with a concrete fix (alt text, a colour that meets the ratio) or a pass with its reason (listed in judged[]). Anything neither can settle is dropped — nothing is left for a human to review. Each judge call sends the page URL, the finding's markup and nearby text, and, when the page can take one, a PNG crop of the element.

Hosted (`https://mcp.webability.io/mcp`): nothing to set. The judge runs on our side with our models, for anonymous and signed-in callers alike: the server posts each uncertain finding to WebAbility's API. If our judge is unreachable, the findings it would have settled are dropped, never guessed.

Local (`npx` / `webability-mcp`): the judge is off until you give it a key. It is not local inference: your machine calls the model endpoint with your key (OpenRouter, or the WEBABILITY_JUDGE_BASE_URL you set). Set OPENROUTER_API_KEY to turn it on (vision anthropic/claude-haiku-4.5, text-only deepseek/deepseek-v4-flash; override with WEBABILITY_JUDGE_BASE_URL, WEBABILITY_JUDGE_VISION_MODEL, WEBABILITY_JUDGE_TEXT_MODEL, budget WEBABILITY_JUDGE_TIMEOUT_MS, default 20 s). WEBABILITY_JUDGE=off disables it in both modes. Without a key, the model-free verdicts still run (a measured contrast pass, a decorative or 1x1 image, a reduced-motion rule) and land in judged[]; findings they cannot settle are dropped.

Structured fixes (since v1.6.0)

Every issue from scan_page, flow_scan, diff_scan and scan_html carries a machine-readable fix and a fixability tier, so an agent can act without parsing prose:

{

"id": "wa-missing_button_type-a1b2c3", "fixability": "mechanical", "fix": { "op": "add-attribute", "attribute": "type", "value": "button", "currentValue": "", "needsManualReview": false } }

fix.value is present only when the engine already knows it. The legacy fix.attribute / currentValue / suggestedValue / needsManualReview fields are unchanged. get_rules lists the tier for every rule so you can pick the auto-fixable set up front.

Source pointers (since v1.6.0)

On a React ≤18 or Vue dev build, scan_page, flow_scan and diff_scan read the component tree of the live page and attach the JSX call site to each finding:

{ "selector": "img#hero", "source": { "framework": "react", "file": "/app/src/Hero.tsx", "line": 12, "column": 5, "component": "Hero" } }

Open that file — no find_source round-trip. React 19 dropped _debugSource; there you still get component. Production builds have no tree; pass sourceRoot (Lite only) and issues without a pointer get sourceCandidates[] from a token grep of the selector.

Output controls (since v1.6.0)

scan_page, flow_scan, scan_html and diff_scan accept:

Filters apply before the 50-item cap, so minImpact: "serious" returns every serious issue on a 300-issue page. The scan_history archive keeps the unfiltered result.

In-process scan_html (since v1.6.0)

scan_html no longer launches a browser by default. It runs the WebAbility detectors and axe-core inside jsdom in the MCP process — milliseconds, no network — and returns the same issues / judged / summary shape as scan_page, with fix.op on every finding. Fragments are wrapped into a document automatically. jsdom has no layout, so visual-tier rules (contrast, target size, focus ring) are skipped and counted in skippedVisual; pass engine: "browser" for the previous headless-Chr