siteone-mcp-server
Click on "Install 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., "@siteone-mcp-serverCrawl https://example.com and list SEO issues"
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.
siteone-mcp-server
MCP server that wraps the SiteOne Crawler CLI for SEO auditing and site analysis. Use it with Claude Code, Claude Desktop, or any MCP-compatible client.
Install SiteOne Crawler
The auto-installer downloads the correct SiteOne Crawler binary for your platform:
npx -y siteone-mcp-server --installThis installs to ~/.siteone-crawler/ and the MCP server will auto-detect it — no further configuration needed.
Supports macOS (arm64, x64) and Linux (arm64, x64). Windows users should download manually.
Related MCP server: crawlie-mcp
Quick Start
Claude Code
claude mcp add siteone -- npx -y siteone-mcp-serverClaude Desktop
Add to your MCP settings (~/.claude/mcp_settings.json):
{
"mcpServers": {
"siteone": {
"command": "npx",
"args": ["-y", "siteone-mcp-server"]
}
}
}Available Tools
Tool | Description |
| Full site crawl — returns JSON with SEO, performance, and security metrics for all URLs |
| Single page analysis — fast, lightweight audit of one URL |
| Crawl a site and generate an XML sitemap file |
| Crawl a site and export all pages as markdown files |
| Quick shallow crawl for health check statistics |
Configuration
The server resolves the SiteOne binary in this order:
--siteone-binCLI argument (highest priority)SITEONE_BINenvironment variable~/.siteone-crawler/crawler(auto-installed location)crawlerin PATH (fallback)
CLI argument
claude mcp add siteone -- npx -y siteone-mcp-server --siteone-bin=/path/to/crawlerOr in Claude Desktop config:
{
"mcpServers": {
"siteone": {
"command": "npx",
"args": ["-y", "siteone-mcp-server", "--siteone-bin=/path/to/crawler"]
}
}
}Environment variables
Variable | Purpose | Default |
| Path to the SiteOne crawler binary | Auto-detected (see above) |
| Working directory for crawl outputs | Current working directory |
Examples
Once configured, ask Claude:
"Crawl https://example.com and summarize the SEO issues"
"Check if https://example.com has any broken links"
"Generate a sitemap for https://example.com"
"Export https://example.com as markdown"
"Give me a quick health check of https://example.com"
Development
# Install dependencies
npm install
# Build
npm run build
# Watch mode
npm run dev
# Test with MCP Inspector
npm run inspectLicense
MIT
Available Tools
5 toolscrawl_single_pageA
Analyze a single page with SiteOne Crawler. Returns JSON data for just the specified URL. Fast and lightweight — use for quick page-level audits.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Target page URL | |
| device | No | Device user agent | desktop |
| extra_columns | No | Additional columns via XPath or regex |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that the tool returns JSON data and is 'fast and lightweight,' giving some behavioral context. However, it does not specify what the analysis includes, whether it performs any mutations, or potential edge cases (e.g., redirects, JavaScript rendering). This leaves gaps that annotations would normally fill.
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?
The description is two sentences, front-loaded with the action and followed by a use case. Every word is purposeful, with no redundancy. It is concise and well-structured, making it easy for an agent to parse quickly.
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?
The tool is simple with 3 parameters and no output schema, so the description must convey the return expectation. It states that JSON data is returned but does not describe the JSON structure or any limitations. Given the context signals (siblings, rich schema), the description is largely complete but lacks details about the response contents, which prevents a 5.
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 100% coverage, with descriptions for all three parameters: url, device, and extra_columns. The description adds no extra meaning beyond referring to 'the specified URL.' Since the schema fully documents the parameters, a baseline score 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 clearly states the tool 'Analyze a single page with SiteOne Crawler' and specifies it 'Returns JSON data for just the specified URL.' This distinguishes it from sibling crawl_site by emphasizing single-page scope and the phrase 'quick page-level audits.' The verb 'analyze' and resource 'single page' are specific and unambiguous.
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 says 'Fast and lightweight — use for quick page-level audits,' which provides a clear use case. It implicitly contrasts with crawl_site by focusing on a single page, but does not explicitly name alternative tools or state when not to use it. The sibling tool names are visible via context signals, so the guidance is adequate 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.
crawl_siteA
Run a full site crawl with SiteOne Crawler. Returns structured JSON with all crawled URLs and their SEO, performance, and security metrics. Use for comprehensive site audits.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Target URL to crawl (must include protocol) | |
| device | No | Device user agent | desktop |
| timeout | No | Per-request timeout in seconds | |
| workers | No | Concurrent workers | |
| max_depth | No | Maximum crawl depth (SiteOne default is unlimited; 10 is safer for MCP use) | |
| extra_columns | No | Additional columns via XPath or regex | |
| disable_images | No | Skip image resources | |
| disable_styles | No | Skip CSS resources | |
| max_reqs_per_sec | No | Max requests per second | |
| disable_javascript | No | Skip JavaScript resources |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns structured JSON but does not mention side effects such as sending a large number of requests to the target site, potential rate limiting, execution time, or error handling. This lack of behavioral transparency beyond the basic action is a significant gap for a potentially heavy operation.
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?
The description is two sentences that front-load the core action and result, and it includes a use case. Every word is purposeful, with 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?
Given the tool's complexity (10 parameters, no output schema), the description provides the core purpose and a use case but lacks behavioral details like execution time, rate limits, and impact on the target site. The return format is described as structured JSON but not detailed; this is acceptable given the schema's parameter coverage, but the description does not fully compensate for the lack of annotations and output schema.
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 100% coverage with descriptions for all 10 parameters, so the description does not need to repeat them. The description adds no additional parameter semantics beyond what the schema provides, meeting the baseline of 3.
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 the tool runs a full site crawl with SiteOne Crawler and returns structured JSON with SEO, performance, and security metrics. This distinguishes it from sibling tools like crawl_single_page by emphasizing 'full' and 'comprehensive site audits.'
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 says 'Use for comprehensive site audits,' which indicates when to choose this tool over alternatives like crawl_single_page. It does not explicitly name alternatives or exclusions, but the context is clear that this is for full-site audits rather than single-page checks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
export_markdownA
Crawl a website and export each page as a markdown file. Returns the export directory path and a crawl summary. Use for content migration, offline analysis, or feeding pages into other tools.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Target URL to crawl | |
| max_depth | No | Maximum crawl depth (SiteOne default is unlimited; 5 is safer for MCP use) | |
| output_dir | No | Export directory name | siteone-markdown-export |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the core action (crawl and export) and the return values (directory path and crawl summary). However, it omits behavioral details such as how the crawl handles page boundaries, link following, rate limits, or potential side effects, leaving a moderate transparency gap.
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?
The description is concise at two sentences, front-loaded with the primary function and return values, followed by a compact list of use cases. Every sentence earns its place with 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?
Given there is no output schema and no annotations, the description adequately covers the essential return information and intended use cases. However, it does not address edge cases like handling external links, file naming specifics, or the impact of max_depth on results, and it does not reference sibling tools for alternative scenarios, making it complete but not exhaustive.
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 covers all three parameters (url, max_depth, output_dir) with descriptions, achieving 100% schema coverage. The description adds no parameter-specific semantics beyond the overall crawl-and-export behavior, so the baseline score 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 clearly states the tool's action: 'Crawl a website and export each page as a markdown file.' It uses a specific verb and resource, and also mentions the return values (export directory path and crawl summary), which distinguishes it from siblings like crawl_site or generate_sitemap that don't focus on markdown export.
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 provides explicit use cases: 'Use for content migration, offline analysis, or feeding pages into other tools.' This gives clear context for when to use the tool. However, it does not explicitly contrast with sibling tools like crawl_site or mention when not to use it, so it lacks explicit exclusions or alternative references.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_sitemapA
Crawl a website and generate an XML sitemap file. Returns the sitemap file path and a crawl summary. Use for SEO audits or submitting sitemaps to search engines.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Target URL to crawl | |
| max_depth | No | Maximum crawl depth (SiteOne default is unlimited; 10 is safer for MCP use) | |
| output_file | No | Output filename for the sitemap | sitemap.xml |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full behavioral transparency. It states it crawls and generates a sitemap, but does not disclose side effects (e.g., writing a file), rate limits, or whether it's safe/read-only. For a tool that creates a file, this is a notable gap.
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?
The description is two sentences, front-loaded with the primary action and return value, followed by a clear use case. Every sentence earns its place; there is no waste or redundancy.
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 3-parameter tool with no output schema, the description conveys the core function, return value, and use case. It is mostly complete, though it could add a note about whether the crawl is limited or has any side effects. Overall, it is adequate for basic usage.
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 covers all 3 parameters with descriptions and defaults, so the description does not need to add parameter details. The description adds no extra meaning beyond the schema, matching the baseline of 3 for full schema coverage.
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 the tool's purpose: 'Crawl a website and generate an XML sitemap file.' It also specifies the return value (file path and crawl summary), making it distinct from sibling tools like crawl_site which only crawl.
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 provides a clear use case ('Use for SEO audits or submitting sitemaps to search engines'), giving context for when to use it. However, it does not explicitly mention alternatives or when not to use it, so it lacks exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_crawl_summaryA
Run a quick, shallow crawl and return only high-level statistics: status code distribution, response times, and error counts. Best for fast site health checks before running a full crawl.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Target URL to crawl | |
| max_depth | No | Shallow crawl depth | |
| rows_limit | No | Max URLs to process (SiteOne default is 200) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, but it only mentions the shallow crawl and returned statistics. It does not disclose potential side effects like network requests to the target site, rate limits, or any mutation risks, though the tool appears read-only. The description adds the 'shallow' behavioral trait, but more detail would be needed for a non-annotated tool.
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?
The description is two sentences, the first directly states the tool's function and outputs, and the second gives usage guidance. It is front-loaded, efficient, and every sentence adds value with no redundancy.
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?
The description explains the high-level return values and health-check use case, which is sufficient for a relatively simple tool without an output schema. It covers purpose, usage, and resource scope, though it could detail error handling or exact output format more, but the essentials are 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?
Schema description coverage is 100%, so the schema already documents all three parameters (url, max_depth, rows_limit). The description adds no parameter-specific meaning beyond hinting at shallowness, which is already captured by max_depth's 'Shallow crawl depth'. 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?
The description clearly states the tool runs a quick, shallow crawl and returns high-level statistics such as status code distribution, response times, and error counts. This specific verb+resource+output distinguishes it from siblings like crawl_site or crawl_single_page, which imply more comprehensive crawling.
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 positions the tool as 'best for fast site health checks before running a full crawl,' giving clear usage context. It implies a complement to full crawls but does not name alternative tools or provide explicit when-not-to-use scenarios beyond the full-crawl distinction.
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. Dates show when Glama detected each change.
5 tool updates
v1.2.0- First observed
crawl_single_page - First observed
crawl_site - First observed
export_markdown - First observed
generate_sitemap - First observed
get_crawl_summary
TDQS
Each tool has a distinct purpose: full site crawl, single page crawl, sitemap generation, markdown export, and summary statistics. Even the overlapping crawl operations differ clearly in scope and output. An agent can reliably select the right tool based on whether it needs metrics, a sitemap, markdown files, or a quick health check.
All tool names follow a consistent verb-first snake_case pattern: crawl_site, crawl_single_page, generate_sitemap, export_markdown, get_crawl_summary. The verbs are descriptive and the noun targets are clear. This is a textbook example of predictable naming.
Five tools is well-scoped for a website crawling server. Each tool covers a distinct use case without redundancy, and the count is neither too sparse nor bloated. The set feels complete for the domain.
The tool surface covers the core operations expected from a crawler: full audit, single page check, sitemap generation, content export, and summary stats. There are no obvious gaps that would block an agent from achieving typical crawl-related tasks. Combined with the provided descriptions, the set appears comprehensive.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Web search, URL content extraction to Markdown, site mapping, and recursive web crawler.
Free technical-SEO audit MCP: crawl a site, run checks, return an LLM-ready shareable report.
- VibeSEOOAuthdev.vibeseo
SEO research, audits, backlinks, GSC, and content workflow tools for AI agents.
Validate HTML/CSS, audit SEO and JSON-LD, check links, and capture responsive screenshots.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI agents to perform comprehensive SEO audits on web pages, including meta tags, headings, links, images, performance, and more, via a CLI or MCP server.181MIT
- AlicenseNot gradedqualityBmaintenanceEnables LLM agents to crawl and audit websites for technical SEO and GEO issues, providing actionable fixes via tools like crawl_site and explain_issue.79101MIT
- FlicenseNot gradedqualityDmaintenanceEnables fetching, crawling, and analyzing web pages with 29 tools for SEO audits, content extraction, and more.-
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to crawl and audit websites for SEO issues, returning structured JSON reports with errors, warnings, and key statistics.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Dorkside/siteone-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server