MCP · GITHUB COPILOT
Copilot writes the code but can't see your live site. Add Prufa's MCP server and it gets a QA engineer: ask it to test your site, get an evidence-gated verdict back.
No signup, no card. A real browser loads your public pages — the audit call blocks for up to ~90 seconds and hands back the verdict.
We pointed this same audit at 49 Show HN launches — 38 of 49 had a critical finding live on day one. Read the data.
GitHub Copilot can't QA-test a running website on its own — its agent
mode can edit files and run terminal commands, but it has no eyes on your
deployed site. Prufa's MCP server gives it those eyes.
Add one stdio entry
to .vscode/mcp.json, then ask Copilot in agent mode to "test
my site." It calls prufa_run_audit, a real browser loads your
pages, plain-code checks grade the captured evidence, and Copilot reads
back a verdict — verified findings separated from advisory opinion. The
first audit on any public URL needs no API key and no card.
Copilot's agent mode is good at the things it can reach: editing files in your workspace, running build commands, reading terminal output. What it can't do is open your deployed site in a browser, click through a flow, watch the network tab, and tell you what actually broke. It has no runtime view of the thing it just built.
That gap is where bugs hide. A signup form that never fires its analytics
event, a cookie set without the Secure flag, a link that
404s, a layout that overflows on a 390px phone — none of those show up in
the source. They only show up when a browser loads the page.
Prufa is an AI QA engineer with the same architecture in every surface: the agent loop navigates and drives a real browser; plain code records the traffic and verifies the result against a spec. The LLM never grades whether a tracking beacon is correct — captured network traffic is asserted against a declarative spec. That separation is what makes the verdict trustworthy instead of a confident guess.
The MCP server is a thin client over that same engine. Once it's registered, GitHub Copilot can call it like any other tool — and it inherits the discipline: severity counts and grades come only from machine-verified findings, while LLM opinion is kept in a separate, clearly-labeled advisory tier. If you'd rather call Prufa straight from your own code instead of through Copilot, the same engine is exposed over the HTTP API. (More on that split in agentic testing vs scripted testing.)
Three steps: register the MCP server, ask Copilot in agent mode to test a URL, and read a verdict that only verified evidence can move.
Add Prufa to .vscode/mcp.json in your workspace (the real snippet is below), or run Command Palette → MCP: Add Server. First start shows a trust dialog — approve it once.
In Copilot Chat (agent mode), say “Run a Prufa audit on https://my-site.com and summarise the critical findings.” Copilot calls prufa_run_audit. A real browser loads your public pages and captures network traffic, console output, cookies, and response codes.
Prufa returns a JSON report with a report_url. Verified findings carry a machine-checked evidence line; advisory (LLM-judged) observations sit in a separate tier and never move a grade. Copilot reads the counts back to you; the full report opens in the browser for a human.
GitHub Copilot reads MCP servers from .vscode/mcp.json in
your workspace — note the top-level key is servers, not the
mcpServers convention you may have seen elsewhere. Prufa's
server installs from PyPI (pip install prufa-mcp), which
puts the prufa-mcp executable on your PATH. The minimal,
anonymous setup needs no key:
{
"servers": {
"prufa": {
"type": "stdio",
"command": "prufa-mcp"
}
}
}{
"inputs": [
{ "id": "prufa_key", "type": "promptString", "password": true }
],
"servers": {
"prufa": {
"type": "stdio",
"command": "prufa-mcp",
"env": { "PRUFA_API_TOKEN": "${input:prufa_key}" }
}
}
}
The left block is enough to run the same
free 60-second website audit
(prufa_run_audit, prufa_get_report) — no key,
no card. To unlock the persistent tools (saved flows, monitors) on a
paid workspace, mint a workspace key in the dashboard and prompt for it
with a VS Code input variable, as in the right block. The
${input:prufa_key} reference only resolves if you
also declare it in the top-level inputs array, so VS Code
prompts once and stores it securely.
A few honest caveats worth stating plainly:
servers, not
mcpServers. VS Code's schema differs from the
Cursor / Cline convention. To enable the server for every workspace,
put the same block under mcp in your user
settings.json instead.
mcp-config.json; the Copilot
Coding Agent is configured at the repo/org level on GitHub, not in
.vscode/mcp.json.
Illustrative rows in the real finding shape
(finding_key · path · time) — the keys, tiers and
severities are exactly what the analyzers emit. Verified tier first,
advisory strictly separate — never interleaved.
A real browser loaded the page and no analytics request fired — you're flying blind on launch traffic.
The page ships no CSP, so an injected script faces no browser-side restriction.
Content runs past the 390px viewport — the page scrolls sideways on a phone.
LLM-judged readability observation. Advisory only — excluded from severity counts and the section grade.
The honest answers to what Copilot users ask before they wire a QA tool into the agent loop.
No. A crawler checks status codes; Prufa drives a real browser through the page, captures the network/console/cookie evidence, and grades it against a spec. The agent loop handles navigation a static script can't (consent walls, client-rendered content). Where you only need an HTTP status check, a curl loop is genuinely simpler and cheaper — use that.
The free audit walks public pages only and doesn't mutate state. Flow execution runs steps you've defined and confirmed; chaos (Gremlin) mutations are dry-run by default and require explicit per-host authorization, and payments are never executed. Monitoring is built so it never pollutes your analytics.
Prufa never reads your repo — it loads your deployed URL like any visitor and inspects what the browser sees. It does not scan for exposed secrets or credentials; that's a deliberate scope limit, not a feature. For source-level review, keep using Copilot itself.
The questions Copilot users and their agents ask before wiring a QA MCP server into the loop.
In VS Code agent mode, create .vscode/mcp.json in your workspace and add a server entry under the top-level servers key (not mcpServers): {"servers":{"prufa":{"type":"stdio","command":"prufa-mcp"}}}, after pip install prufa-mcp. Or use Command Palette → MCP: Add Server. VS Code shows a trust dialog on first start. To enable it for every workspace, put the same block under mcp in your user settings.json.
Only agent mode. MCP tools surface to Copilot's agent loop, not to inline completions or plain chat. In VS Code that means Copilot Chat switched to agent mode. The Copilot CLI is configured separately via its own mcp-config.json, and the Copilot Coding Agent is configured at the repo or org level on GitHub — not in .vscode/mcp.json. An org or enterprise policy can disable MCP entirely.
The audit tools are free. prufa_run_audit and prufa_get_report run a one-shot audit on any public URL with no API key and no card — the call blocks for up to ~90 seconds and hands the findings JSON back to Copilot. Persistent tools (saved flows, scheduled monitors) need a workspace key from a paid plan; a free-tier call to those returns a clear payment-required error with a checkout link, passed straight through to Copilot.
Yes, for what a browser can see. When Copilot calls prufa_run_audit, a real browser loads your public pages and a fixed suite of deterministic checks grades the captured traffic — tracking, SEO, performance, accessibility, forms, consent, security, and more. Copilot reads back severity counts and a report URL. Multi-step flows (login, checkout) are a separate confirmed-flow tool, not part of the anonymous audit.
Run a free audit on your live URL now to see the report Copilot will read
— then drop the .vscode/mcp.json snippet in and ask it to
test your site.