SyteCheck MCP Server
SyteCheck MCP Server lets you run and manage website audits from an MCP client, returning scored plain-language reports.
run_scan: Submit a URL for a full audit (HTML, SEO, broken links, accessibility, performance, security headers, responsive layout, AI visibility, freshness, visual critique); spends monthly quota.
get_scan_report: Fetch full findings for a scan ID, including executive summary and per-category results.
list_scans: Browse past scans, newest first, with filtering by status, URL/label, and pagination.
get_scan_trends: View score history per URL across repeat scans to see improvement or regression.
list_categories: See which audit categories exist and which your account plan includes.
get_account_usage: Check scans remaining this month, plan details, and quota reset.
scan-and-remediate prompt: Scan a URL and get a prioritized fix plan.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@SyteCheck MCP ServerRun a full website audit on https://example.com and give me the report."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
SyteCheck MCP Server
Run website audits from Claude, Cursor, or any other MCP client, and get the findings back as text you can act on.
SyteCheck scans a page across ten dimensions — HTML validity, SEO, broken links, accessibility (WCAG 2.2 AA via axe-core), performance (a real Lighthouse run), security headers, responsive layout, AI visibility, content freshness, and an AI critique of the visual design — and returns a scored, plain-language report.
A free account works. No card, no trial clock: the free tier includes three scans a month across three categories, which is enough to wire this up and see a real report before deciding whether to pay for more.
Quickstart
Create an account at sytecheck.app and verify your email.
Mint a key at Account → API keys. Choose
scans:readonly if you want the model to read existing scans but never spend quota. The secret is shown once.Add the server to your client, using one of the recipes below.
Claude Code
claude mcp add sytecheck --env SYTECHECK_API_KEY=sck_your_key_here \
-- npx -y @ascentws/sytecheck-mcpClaude Desktop
Edit claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"sytecheck": {
"command": "npx",
"args": ["-y", "@ascentws/sytecheck-mcp"],
"env": { "SYTECHECK_API_KEY": "sck_your_key_here" }
}
}
}Cursor
Add to .cursor/mcp.json in your project, or the global equivalent:
{
"mcpServers": {
"sytecheck": {
"command": "npx",
"args": ["-y", "@ascentws/sytecheck-mcp"],
"env": { "SYTECHECK_API_KEY": "sck_your_key_here" }
}
}
}Gemini CLI / Antigravity CLI
Add to ~/.gemini/settings.json (or the Antigravity equivalent):
{
"mcpServers": {
"sytecheck": {
"command": "npx",
"args": ["-y", "@ascentws/sytecheck-mcp"],
"env": { "SYTECHECK_API_KEY": "sck_your_key_here" }
}
}
}OpenAI Agents SDK
from agents import Agent
from agents.mcp import MCPServerStdio
sytecheck = MCPServerStdio(
params={
"command": "npx",
"args": ["-y", "@ascentws/sytecheck-mcp"],
"env": {"SYTECHECK_API_KEY": "sck_your_key_here"},
}
)
agent = Agent(
name="Site auditor",
instructions="Audit sites with SyteCheck and explain what to fix.",
mcp_servers=[sytecheck],
)Then ask: "Scan https://example.com and tell me what to fix first."
Related MCP server: SEO Audit MCP
Tools
Tool | What it does |
| Submit a URL and wait for the report. Spends quota. |
| Full findings for a scan id — the way to collect a scan |
| Scan history, newest first, with filters |
| Score history per URL across repeat scans |
| What SyteCheck can check, and what your plan includes |
| Scans remaining this month, and when the quota resets |
There is also a scan-and-remediate prompt that scans a URL and turns the
findings into a prioritized fix plan.
A note on cost
run_scan is the only tool that spends anything, and it spends real money: a scan
opens a browser, runs Lighthouse, and calls a vision model. It is marked
non-read-only so your client asks before running it, and its description tells the
model to check remaining quota first and not to re-scan an unchanged page. On a
free account you have three scans a month — an agent looping over run_scan
would exhaust that in one turn.
If you are handing a key to something unattended, mint a scans:read key. It
cannot create scans at all.
Configuration
Variable | Default | Purpose |
| (required) | Your |
|
| API base URL |
|
| How long |
|
| Gap between status checks while waiting |
Note the API host is api.sytecheck.app, not sytecheck.app — the latter
serves the web app and answers API paths with its "page not found" screen.
Using the API directly
The MCP server is a thin client over a plain HTTP API you can call yourself.
docs/API.md — the full developer guide: authentication, submitting scans, polling, webhooks and their signature verification, rate limits, and versioning.
public-openapi.json — the OpenAPI 3.1 spec, for generating a client.
examples/ — runnable clients in curl, Python, Node, Java, and C#, plus a webhook receiver that verifies the delivery signature.
Interactive docs: Swagger UI · ReDoc
Development
npm install
npm run build
npm test
npm run lintTo run against a local SyteCheck instance:
SYTECHECK_API_KEY=sck_… SYTECHECK_API_URL=http://localhost:8000 node dist/index.jsThe server speaks JSON-RPC over stdin and stdout, so nothing may be written to
stdout except protocol messages — a stray console.log corrupts the stream and
the client disconnects with an unhelpful parse error. Diagnostics go to stderr.
Security
See SECURITY.md for how the key is handled, what a leaked key can and cannot do, and how to report a vulnerability.
License
MIT — see LICENSE. The licence covers this code; the SyteCheck name and mark are trademarks of Ascent Web Solutions, and use of the service is governed by its Terms of Service. See TRADEMARK.md for the full terms.
Available Tools
6 toolsget_account_usageGet account usage and quotaARead-only
How many scans this account has left this month, its plan, and which categories it may run. Check this before running scans in bulk — quota is per calendar month and does not roll over.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds a meaningful non-obvious behavioral fact: quota resets per calendar month and does not roll over. This extra context helps agents avoid misinterpreting stale quota values, which is more than the annotations alone provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: the first states what the tool returns, the second gives actionable usage guidance and a key rule. No redundant words; every part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only status tool without an output schema, the description is complete: it explains the data returned, the timing caveat, and when to invoke it. Nothing an agent needs to correctly select and call this tool is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the input schema is complete, so the description has no need to explain parameters. Baseline of 4 is appropriate given the absence of parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the resource (account usage and quota) and the specific information returned: scans left, plan, and allowed categories. This distinguishes it from siblings like get_scan_report or list_scans by focusing on account-level quota rather than individual scans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells the agent to check this before bulk scan operations, providing a clear triggering condition. It does not name alternative tools for exclusions, but the context makes the tool's role as a pre-flight check obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_scan_reportGet a scan reportARead-only
Fetch the full findings for a scan by id, including the executive summary and per-category results. Use this to collect a scan that run_scan left running, or to re-read an earlier scan without spending quota.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Optional BCP-47 language for the report text, e.g. 'fr' or 'ja'. | |
| scan_id | Yes | The scan's id. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read profile is covered. The description adds genuine context beyond that: the shape of the return payload (executive summary plus per-category results) and the quota-free nature of repeated reads. It stops short of describing behavior when a scan is still running or any rate/latency characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the action and payload front-loaded, followed by the usage rationale. No filler, no restatement of the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description usefully sketches the return contents and the quota behavior that motivates re-reading. The one gap is what happens if the referenced scan has not finished (partial vs pending results), which matters given the 'collect a scan that run_scan left running' framing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both scan_id and lang documented in the schema itself. The description only reinforces that lookup is 'by id' and adds nothing about the lang parameter or id constraints, so the schema carries the full burden as expected at baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Fetch the full findings for a scan by id') and enumerates what the payload contains ('executive summary and per-category results'). It also positions itself relative to run_scan, so an agent can distinguish this read-only retrieval from the scan-creating sibling without opening schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives two concrete selectors: collecting a scan that run_scan left running, and re-reading an earlier scan without spending quota. It names the relevant alternative (run_scan) and the condition that favors this tool, though it does not state explicit exclusions or point to list_scans for enumeration.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_scan_trendsGet score trendsARead-only
Score history per URL across repeated scans — whether a site is improving or regressing over time. Returns nothing useful for a site scanned only once.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide readOnlyHint=true and openWorldHint=true. The description adds the behavioral nuance that the tool returns nothing useful for a site scanned only once and that it surfaces trends, which goes beyond the annotations. However, it does not describe return shape, pagination, or any other noteworthy runtime behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, highly efficient. The first sentence states the purpose, the second adds a crucial edge-case warning. There is no filler or repetition, and the main concept is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (zero params, no output schema), the description gives enough for an agent to understand its purpose, expected data, and pitfall. It does not describe the exact output format, but the absence of an output schema and a straightforward read-only function makes that a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters and the schema is empty, so the description does not need to explain parameter meaning. The baseline of 4 for no parameters applies, and the description's focus on behavior aligns with the empty input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states this tool returns score history per URL across repeated scans and indicates trend direction. It differentiates from siblings like get_scan_report through the 'repeated scans' framing, but it does not explicitly name or contrast any alternative tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The use case is clear: use this when you need to see whether a site is improving or regressing across multiple scans. It also gives a when-not case ('site scanned only once'), but it does not explicitly mention sibling tools that should be used instead, such as get_scan_report or list_scans, so usage guidance is strong but not fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_categoriesList scan categoriesARead-only
The analysis categories SyteCheck can run, and which of them this account's plan includes. Check this before passing categories to run_scan — requesting one the plan withholds is refused outright rather than skipped.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool read-only, and the description adds meaningful behavioral context: results are plan-dependentchers, and run_scan refuses rather than skips unavailable categories. This goes beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, both information-dense. The first states the purpose, the second gives a precise usage directive. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless listing tool, the description completely covers what it returns (categories and plan inclusions), why to use it, and its relationship to run_scan. Nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so there is nothing for the description to add about parameters. The baseline of 4 fits because no parameter documentation is required, and the description still clarifies what the list contains.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource ('analysis categories SyteCan can run') and adds plan-specific scope ('which of them this account's plan includes'). It reads as an explicit listing tool and is distinguishable from run_scan, which is about executing scans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs the agent to check this tool before calling run_scan推理 and warns that requesting a withheld category is refused outright. This gives a clear decision rule for when to invoke the tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_scansList past scansARead-only
List this account's scans, newest first. Use it to find a scan id, or to check whether a site has been scanned before starting a new one.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | 1-based page number. | |
| query | No | Filter by URL or label substring. | |
| status | No | Filter by scan status. | |
| page_size | No | Results per page (max 100). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds the ordering ('newest first') and account scoping, which is real behavioral context, but says nothing about pagination defaults or result volume beyond what the schema documents.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the ordering constraint front-loaded and the practical uses immediately after. No filler or restated boilerplate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description implies the return content by mentioning finding a 'scan id'. For a simple four-param, zero-required listing tool whose annotations cover safety, that is nearly complete, though it could note that results are paginated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so page, page_size, query and the status enum are all self-documenting. The description adds no syntax or filtering guidance beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('List this account's scans') plus the ordering ('newest first'), which lets an agent distinguish it from the single-scan sibling get_scan_report. It does not explicitly name any sibling, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives two concrete use cases: locating a scan id and checking whether a site has already been scanned before starting a new one (implicitly routing to run_scan). Clear context, though no explicit when-not-to-use or alternatives by name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
run_scanRun a website scanA
Submit a URL to SyteCheck and wait for the report. Scans ten dimensions of site quality: HTML validity, SEO, broken links, accessibility (WCAG 2.2 AA), performance (Lighthouse), security headers, responsive design, AI visibility, content freshness, and an AI visual critique of the design.
IMPORTANT: each scan consumes one of the account's monthly scans and costs real money. Free accounts get three per month. Check get_account_usage first if you are unsure of the remaining quota, and confirm with the user before scanning the same URL more than once — repeat scans of an unchanged page rarely tell you anything new.
A scan usually takes a few minutes. If it is still running when this returns, you get the scan id — pass it to get_scan_report to collect the result rather than scanning again.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Full URL to scan, including https:// | |
| label | No | Optional name for this scan. | |
| categories | No | Category ids to run. Omit for everything the plan includes. Use list_categories to see what this account may request. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare the safety profile (readOnly=false, idempotent=false, openWorld=true); the description adds the substantive traits an agent needs — monetary/quota cost per call, free-tier limit of three per month, multi-minute latency, and asynchronous return of a scan id. This is disclosure well beyond what the annotations provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short paragraphs, front-loaded with the core action, then the critical cost warning, then the async-handoff instruction. Every sentence carries distinct operational value with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by explaining that a still-running scan returns a scan id to be passed to get_scan_report. Combined with the quota and latency warnings, an agent has everything needed to invoke this correctly on the first attempt.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so url, label, and categories are already documented in the schema, including the pointer to list_categories. The description adds no parameter-level syntax or format detail beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Submit a URL to SyteCheck') and enumerates the ten quality dimensions the scan covers, so an agent knows exactly what comes back. The scope is clearly distinct from siblings like get_scan_report or list_scans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly routes to get_account_usage to check quota, instructs confirming repeat scans with the user, and names get_scan_report as the alternative when the scan is still running. It states both when to use the tool and when not to re-invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- Changed
get_scan_report2 fields changed- removed
Input schema / additionalPropertiesRemoved value: -false - added
Input schema / properties / scan_id / maximumAdded value: +9007199254740991
- Changed
list_scans2 fields changed- removed
Input schema / additionalPropertiesRemoved value: -false - added
Input schema / properties / page / maximumAdded value: +9007199254740991
- Changed
run_scan1 field changed- removed
Input schema / additionalPropertiesRemoved value: -false
6 tool updates
v0.1.0- First observed
get_account_usage - First observed
get_scan_report - First observed
get_scan_trends - First observed
list_categories - First observed
list_scans - First observed
run_scan
TDQS
Scored across 6 tools
Each tool targets a distinct object and action: run_scan creates, get_scan_report reads one scan's findings, get_scan_trends reads history per URL, list_scans indexes scans, list_categories describes analyzers, get_account_usage reports quota. The report/trends/list distinction is spelled out in the descriptions, so misselection is unlikely.
All six names follow a strict verb_noun snake_case pattern (get_*, list_*, run_*). Verbs are used consistently: get_ for single-resource fetches, list_ for collections, run_ for the mutating action.
Six tools covering quota, categories, submission, retrieval, listing, and trends is well-matched to a single-purpose scanning service with no redundant entries. Nothing feels padded or missing at the count level.
The core lifecycle (check quota/categories, submit scan, collect report, review trends, list history) is fully covered. Minor gaps exist, such as no way to cancel or delete a scan, but these are workable and scans are likely immutable.
Maintenance
Related MCP Connectors
Audit, rank-track and analyze SEO for sites via an authenticated MCP server.
Run full technical SEO audits of any website from your AI agent and get structured findings back.
Website QA for your coding agent: audit SEO, performance, security, accessibility over MCP.
Audit public webpages and supplied markup for HTML, CSS, SEO, JSON-LD, and link issues.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables auditing of websites for performance, SEO, accessibility, security, and mobile readiness, with tools to validate URLs, run page audits, save results, and retrieve reports.1-
- AlicenseNot gradedqualityDmaintenanceEnables running comprehensive SEO audits on websites, checking meta tags, sitemaps, robots.txt, broken links, headings, duplicate titles, and keyword density through MCP tools.3 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables AI clients to perform bounded website Quick Audits via MCP tools, covering crawlability, indexability, and metadata.1MIT
- AlicenseNot gradedqualityAmaintenanceExposes website auditing, finding retrieval, and safe fix application as MCP tools so AI agents can diagnose and remediate SEO, accessibility, and technical web issues.2MIT