RGate MCP server scans public websites for release-readiness across five quality layers: security, SEO, accessibility, legal compliance, and sustainability. Here's what you can do:
Start a scan (start_scan): Kick off an asynchronous scan for any public URL.
Poll scan status & retrieve results (get_scan): Monitor scan progress and fetch structured findings, check results, tech detections, and an agent summary once complete. Supports report tokens for full, non-redacted access.
Unlock a free report (unlock_report): During active campaigns, submit an email to receive a 24-hour token granting full access to findings and fix plans at no cost.
Create a checkout handoff (create_checkout_handoff): Generate a URL to send a human to purchase a full report or subscription when a report is paywalled.
Browse the check catalog (list_checks): Explore all checks RGate performs, optionally filtered by layer.
Get pricing info (get_pricing): Retrieve machine-readable plan details including names, prices, billing periods, scan limits, and use cases.
Generate a fix plan (generate_fix_plan): Build a prioritized, implementation-ready fix plan from scan findings — release blockers first, then high-impact items, then backlog — in JSON or Markdown, optionally filtered by layer.
Export scan as Markdown (export_scan_markdown): Export results using templates suited for Cursor agent prompts, GitHub issues, or executive summaries.
Compare two scans (compare_scan_history): Diff two completed scans of the same domain to identify added, resolved, improved, or worsened findings — useful for tracking progress or catching regressions after a deploy.
Allows exporting scan results as a GitHub issue body for tracking website quality improvements.
RGate is the release gate agents call before they tell users a public website is ready to ship.
This repository documents the public RGate MCP server for agentic IDEs, coding agents, and MCP clients. The RGate product source code is not published here; this repo is the public integration and directory listing home for the operated MCP endpoint.
MCP endpoint: https://www.rgate.io/api/mcp
Transport: Streamable HTTP
Manifest: https://www.rgate.io/.well-known/mcp.json
OpenAPI: https://www.rgate.io/openapi.json
Agent guide: https://www.rgate.io/agents.md
Developer docs: https://www.rgate.io/en/developers
Agent recipes: https://www.rgate.io/en/agent-recipes
Related MCP server: blop
RGate scans public websites across five release-readiness layers:
Security
SEO
Accessibility
Legal compliance
Sustainability
Agents can start a scan, poll structured results, inspect the check catalog, generate fix plans, export Markdown, compare scan history, and hand paid report access back to a human.
{
"mcpServers": {
"rgate": {
"url": "https://www.rgate.io/api/mcp",
"transport": "streamable-http"
}
}
}Tool | Purpose |
| Start an RGate website quality scan for a public URL. |
| Fetch scan status and, once complete, structured findings and results. |
| Describe RGate scan layers and the check catalog. |
| Return machine-readable plan names, prices, limits, and use cases. |
| Create a human handoff URL for purchasing report access or a subscription. |
| Generate a prioritized release-readiness fix plan from findings. |
| Export scan results as Markdown for Cursor, GitHub issues, or summaries. |
| Compare two scans and return added, resolved, improved, and worsened findings. |
Confirm the user is allowed to scan the public website.
Call start_scan with the public URL.
Poll get_scan with the returned scanId until status is done or failed.
If the target passed green, report that the website passed the release gate.
If access is locked, send the human to the report URL for checkout and poll the same scanId again after payment.
Generate a fix plan or Markdown export for the coding agent working on that project.
CLI: npm install -g @rgate_io/rgate
Skill: npx skills add marcoldenburg/rgate-release-readiness-skill
Skill repository: https://github.com/marcoldenburg/rgate-release-readiness-skill
Glama: glama.json at repo root (maintainer claim for listing)
Name: rgate
Title: RGate
Description: Release gate agents call before they tell users a public website is ready to ship. Scans public websites across security, SEO, accessibility, legal compliance, and sustainability.
Tags: developer-tools, release-readiness, mcp, agent-tools, website-audit, security, seo, accessibility, compliance, sustainability
RGate is a remote MCP server hosted at https://www.rgate.io/api/mcp
(transport: Streamable HTTP). Some runners — including Glama's automated
build/quality check — start a local stdio process and speak MCP to it. This
repo doubles as a thin stdio↔remote bridge for exactly that:
npm install
npm start # = mcp-remote https://www.rgate.io/api/mcpBuild steps: ["npm install"]
Start command: npm start (or mcp-remote https://www.rgate.io/api/mcp)
Node.js ≥ 18; Python/base-image defaults are fine.
For direct clients (Cursor, Claude, VS Code) just use the remote URL from
mcp.json — no bridge needed.
Diff two completed scans of the SAME domain and return added, resolved, improved, and worsened findings. Read-only. Both scans must be done. Use to verify that fixes landed between two runs, or to catch regressions after a deploy.
Inputs: scanId (required), againstScanId (required), token.
Create a human handoff URL for purchasing a full report or subscription after a scan is complete. Behavior: creates a checkout/upgrade link and returns { handoffUrl }. The agent CANNOT complete payment itself — give the URL to the user to finish in a browser. Use only when the report is paywalled (get_scan shows access.level teaser with payment_required true) AND no free campaign is active. During a campaign, prefer unlock_report.
Inputs: planId (required), scanId (required).
Export a completed scan as Markdown in one of three templates: cursor (an agent fix prompt), github (an issue body), or executive (a stakeholder summary). Read-only. Requires full access — pass a token for a locked report. Use to hand results into an IDE/coding agent or a ticket.
Inputs: scanId (required), token, template.
Build a prioritized, implementation-ready fix plan from a completed scan's findings: release blockers first, then high-impact follow-ups, then backlog. Read-only (derives from stored findings). Returns JSON (or Markdown). Requires full access: on a locked report it returns HTTP 402, or — during a campaign — a teaser with unlock instructions; pass a token from unlock_report or a paid unlock. Call after get_scan shows status done.
Inputs: scanId (required), token, format, layers, +1 more.
Return machine-readable RGate pricing: plan ids, names, prices (EUR/USD), billing period, scan limits, and best-fit use cases. Read-only, static, no arguments. Use to answer pricing questions or choose a planId for create_checkout_handoff.
Inputs: no named parameters.
Poll a scan and, once complete, return its structured results. Read-only. Returns { scan, findings, checkResults, techDetections, access, agentSummary }. scan.status moves through pending → running → retrying → done → failed; keep polling (every few seconds) until done or failed. On failed, a failure object explains the cause and next_action. access.level is none | teaser | full: teaser findings are diagnostic only (evidence, check keys, and fix text are redacted). To get full data, pass a report token via the token argument. If access.campaign is present the report is FREE right now — call unlock_report with an email to obtain that token instead of sending the user to checkout.
Inputs: scanId (required), token.
Return the RGate scan-layer and check catalog. Read-only, static, no side effects — safe to call any time. Use it to plan a scan, explain coverage to a user, or map a finding to its layer. Pass a layer to focus on just that layer's checks.
Inputs: layer.
Start a website release-readiness scan for a public URL across five layers: security, SEO, accessibility, legal compliance, and sustainability. Behavior: enqueues an asynchronous job and returns immediately with a scanId — it does NOT wait for results, and it fetches/renders the target site (not a read-only call). Returns { scanId, status, cached }; identical URLs within ~10 minutes return the cached scan. Next step: poll get_scan with the scanId until status is "done" or "failed". Use this first, once per site; do not busy-loop calling start_scan for the same URL.
Inputs: url (required).
Unlock a completed scan's full findings and fix plan for free during an active campaign. Behavior: records the submitted email as a lead and issues a 24h report token (not read-only). Returns { token, expires_at, report_url }. Only works while a free campaign is active (otherwise returns 403 — use create_checkout_handoff instead). Call this only when get_scan shows access.campaign; then re-poll get_scan or call generate_fix_plan with the returned token.
Inputs: email (required), scanId (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 9 tools
Each tool has a distinct function: starting scans, polling results, comparing histories, exporting reports, generating fix plans, handling pricing and unlocks, and listing checks. No two tools overlap in purpose; descriptions clearly differentiate them.
All tool names follow a consistent verb_noun pattern in lowercase snake_case. Verbs like start, get, create, export, generate, compare, list, unlock are all imperative and paired with specific nouns.
With 9 tools, the server covers the core scanning lifecycle without being bloated. Each tool serves a necessary role in the workflow: initiating, monitoring, analyzing, and monetizing scans.
The tool set covers the full scan workflow: start, poll, compare, export, fix generation, and payment. A minor gap is the lack of a tool to list or manage historical scans, but the core use cases are well supported.
Pre-launch website QA: deterministic rule-based scans, readiness score, and blockers for agents.
Scan any public site for AI-agent visibility; get scored findings, a machine-readable fix pack, and
Review frontend code and live pages against 386 quality-gated web development rules.
Public-site SEO/AEO readiness scans with evidence scores, issues, and clear measurement scope.
