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, ChatGPT, 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: status-global-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, so the safety profile is covered. The description adds useful behavioral context beyond annotations: the tool does not spend quota on re-reads, and it returns full findings including executive summary and per-category results. This goes beyond what annotations alone communicate, though it does not describe the exact output shape.
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 with no filler. The first sentence states what the tool does and what is included; the second gives clear usage context. Key information is front-loaded and every sentence 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 simple two-parameter read-only tool with no output schema, the description is complete enough: it identifies the input (scan id), the returned content (full findings, executive summary, per-category results), and the relevant use cases. No critical operational context is missing for an agent to invoke it correctly.
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 the parameters scan_id and lang are already fully documented in the schema. The description adds no additional parameter-level meaning beyond referring to 'a scan by id'. With full schema coverage, the baseline of 3 is appropriate.
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 uses a specific verb ('Fetch') and a clear resource ('full findings for a scan by id'), and further specifies the contents as 'the executive summary and per-category results.' This clearly differentiates the tool from siblings like list_scans and get_scan_trends, which serve different reporting or listing purposes.
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 description explicitly states when to use the tool: 'to collect a scan that run_scan left running' or 'to re-read an earlier scan without spending quota.' This names the originating sibling (run_scan), provides a concrete trigger condition, and explains the advantage over re-running a scan.
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 mark the operation as read-only, and the description adds useful behavioral context: account scoping, reverse chronological ordering, and the practical implication that the data can be consulted before launching a new scan. No contradiction exists.
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 tightly written sentences: the first states exactly what the tool does, and the second gives concrete use cases. No filler or repetition of schema details.
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 read-only list operation, the description conveys scope, ordering, and typical usage. It does not describe the exact return fields or pagination behavior, but the schema explains filters and pagination, and 'find a scan id' implies the relevant output.
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 documents all four parameters with descriptions, constraints, and an enum, so the description needs to add little. The description does not expand on parameter behavior, but schema coverage is 100%, so a baseline 3 is appropriate.
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 ('List'), a resource ('this account's scans'), and a behavior ('newest first'). The use cases 'find a scan id' and 'check whether a site has been scanned' clearly distinguish it from sibling tools like run_scan and get_scan_report.
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?
Clearly tells the agent when to use this tool: to locate a scan id or avoid duplicate scans before starting a new one. It does not explicitly contrast with siblings such as get_scan_report, but the intended use cases are concrete and actionable.
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 indicate that the tool is not read-only and not idempotent. The description adds crucial behavioral details: each scan consumes a monthly quota and incurs real cost, free accounts have three scans per month, scans take a few minutes, and the tool may return a scan id for an in-progress scan. This goes well beyond the annotations and is essential for correct agent 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?
Although the description is long, every sentence serves a purpose: the core action, the ten dimensions, the quota warning, the confirmation guidance, and the async fallback. It is front-loaded with the action and the most critical limitation (cost), and the structure flows logically from invocation to follow-up. There is no irrelevant 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 tool that creates a scan (a side effect with cost) and has no output schema, the description covers all critical context: what it does, what it costs, how long it takes, how to handle an async result by passing the scan id to get_scan_report, and how to avoid wasteful duplicates. Everything an agent needs to call it correctly and responsibly is present.
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 already describes all three parameters with 100% coverage, so the baseline is 3. The description adds little extra meaning: it mentions that categories are optional, that omitting them uses the plan's default, and that list_categories can be used to see available categories—but these are largely restatements of the schema descriptions. No new semantic nuance is provided that isn't already in the 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 opens with a concrete verb and resource: 'Submit a URL to SyteCheck and wait for the report.' It enumerates the ten dimensions scanned, which are specific and informative. This clearly distinguishes it from sibling tools like get_scan_report, which retrieves an existing report, and list_scans, which lists previous 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?
The description gives explicit when-to-use guidance: it instructs the agent to check get_account_usage when quota is uncertain, and to confirm with the user before re-scanning the same URL. It also tells the agent to use get_scan_report if the scan is still running, rather than re-scanning. This directly points to alternatives and defines the conditions that trigger them.
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.
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 concern: running scans, fetching reports, listing scans, viewing trends, listing categories, and checking quota. There is no overlap between them.
All tool names follow a consistent verb_noun pattern: run_scan, get_scan_report, list_scans, get_scan_trends, list_categories, get_account_usage. The pattern is uniform and predictable.
Six tools is well-scoped for a scan-oriented service: the set covers the full workflow without redundancy or bloat. Each tool earns its place.
The surface covers the full scan lifecycle: quota check, category discovery, scan initiation, result retrieval, history listing, and trend analysis. A minor gap is the lack of a cancel/delete operation, but that is not essential for the domain.
Maintenance
Related MCP Connectors
Rule-based site audits: accessibility, SEO, security headers, performance. Metered per call.
Website QA for your coding agent: audit SEO, performance, security, accessibility over MCP.
Free technical-SEO audit MCP: crawl a site, run checks, return an LLM-ready shareable report.
AI website audit: security, SEO, performance, UX and accessibility checks with actionable fixes.
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 web audits for performance, security, SEO, and DNS, returning structured improvement prompts for AI assistants.5 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables running comprehensive SEO audits on websites, checking meta tags, sitemaps, robots.txt, broken links, headings, duplicate titles, and keyword density through MCP tools.4 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables AI clients to perform bounded website Quick Audits via MCP tools, covering crawlability, indexability, and metadata.MIT