SEO Audit MCP Server
Provides SEO auditing tools that validate against Google's requirements, including JobPosting schema validation and recommendations for Google Indexing API implementation
Runs Lighthouse performance audits to measure Core Web Vitals, accessibility, SEO scores, and provides optimization recommendations
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., "@SEO Audit MCP Server crawl https://example.com/jobs and check for JobPosting schema 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.
SEO Audit MCP Server
A Model Context Protocol (MCP) server that provides comprehensive technical SEO auditing tools, optimized for job board websites.
Features
Page Analysis - Deep analysis of individual pages including meta tags, headings, structured data, rendering behavior, and links
Site Crawling - Multi-page crawling with automatic page type classification
Lighthouse Integration - Core Web Vitals and performance auditing
Sitemap Analysis - Robots.txt and XML sitemap parsing with job-specific insights
JobPosting Schema Validation - Specialized validation against Google's requirements
Related MCP server: Accrue SEO
Installation
Prerequisites
Node.js 18+
Chrome/Chromium (for Playwright)
Lighthouse CLI (optional, for performance audits)
Setup
# Clone or extract the project
cd seo-audit-mcp
# Install dependencies
npm install
# Install Playwright browsers
npx playwright install chromium
# Install Lighthouse globally (optional but recommended)
npm install -g lighthouse
# Build the project
npm run buildConfigure Claude Desktop
Add to your Claude Desktop configuration (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"seo-audit": {
"command": "node",
"args": ["/path/to/seo-audit-mcp/dist/index.js"]
}
}
}Configure Claude CLI
Add to your Claude CLI config or use directly:
# Using npx (after npm link)
claude --mcp-server "node /path/to/seo-audit-mcp/dist/index.js"Available Tools
analyze_page
Analyze a single web page for SEO factors.
Input:
- url (required): The URL to analyze
- waitForSelector: CSS selector to wait for (for JS-heavy pages)
- timeout: Timeout in milliseconds (default: 30000)
- device: 'desktop' or 'mobile' (default: desktop)
Output:
- Meta tags, headings, structured data
- JobPosting schema validation
- JavaScript rendering analysis
- Link and image analysiscrawl_site
Crawl multiple pages starting from a URL.
Input:
- startUrl (required): Starting URL
- maxPages: Maximum pages to crawl (default: 50)
- maxDepth: Maximum link depth (default: 5)
- includePatterns: Regex patterns to include
- excludePatterns: Regex patterns to exclude
Output:
- Aggregated statistics
- Page type classification (job detail, category, location pages)
- Duplicate detection
- Critical issues and warningsrun_lighthouse
Run Lighthouse performance audit.
Input:
- url (required): URL to audit
- device: 'mobile' or 'desktop' (default: mobile)
- categories: Array of categories to audit
- saveReport: Save HTML report (default: false)
Output:
- Performance, Accessibility, Best Practices, SEO scores
- Core Web Vitals (LCP, CLS, TBT, FCP, TTFB)
- Optimization opportunities
- Diagnosticsanalyze_sitemap
Analyze robots.txt and XML sitemaps.
Input:
- baseUrl (required): Base URL of the site
- includeSitemapUrls: Include full URL list (default: true)
- maxUrls: Max URLs per sitemap (default: 1000)
Output:
- robots.txt rules and issues
- Discovered sitemaps
- Job URL detection
- Recommendationscheck_urls
Check HTTP status codes for multiple URLs.
Input:
- urls (required): Array of URLs to check
- timeout: Timeout per URL in milliseconds
Output:
- Status code, redirect destination, response time per URLUsage Examples
Quick Page Audit
"Analyze the SEO of https://example.com/jobs/software-engineer"Full Site Audit
"Crawl https://example.com and analyze their job board SEO.
Focus on structured data and landing pages."Performance Check
"Run a Lighthouse audit on https://example.com/jobs for mobile devices"Job Board Discovery
"Analyze the sitemap for https://example.com and find their job posting pages"Job Board Specific Features
This tool is optimized for job boards with:
JobPosting Schema Validation
Validates all required fields (title, description, datePosted, etc.)
Checks recommended fields (validThrough, baseSalary, employmentType)
Remote job validation (applicantLocationRequirements)
Expiration date checking
Page Type Classification
Job detail pages
Job listing/search pages
Category landing pages (e.g., /marketing-jobs/)
Location landing pages (e.g., /jobs-in-new-york/)
Company profile pages
Expired Job Handling Analysis
Detects 404s, redirects, and soft 404s
Checks validThrough dates in schema
Recommends proper handling strategies
Recommendations
Google Indexing API implementation
Job-specific sitemaps
Landing page architecture
Development
# Run in development mode
npm run dev
# Run tests
npm test
# Lint code
npm run lintArchitecture
src/
├── index.ts # Entry point
├── server.ts # MCP server implementation
├── tools/
│ ├── index.ts # Tool registry
│ ├── crawl-page.ts # Single page analysis
│ ├── crawl-site.ts # Multi-page crawler
│ ├── lighthouse.ts # Performance audits
│ └── sitemap.ts # Sitemap/robots analysis
├── types/
│ └── index.ts # TypeScript definitions
└── utils/
├── browser.ts # Playwright helpers
└── http.ts # HTTP utilitiesTroubleshooting
Playwright Issues
# Reinstall browsers
npx playwright install chromium --force
# On Linux, you may need system dependencies
npx playwright install-depsLighthouse Not Found
# Install globally
npm install -g lighthouse
# Or use npx (slower)
npx lighthouse --versionPermission Errors
The server needs to write to /tmp for temporary files. Ensure proper permissions.
Timeout Errors
For slow sites, increase timeouts:
Page analysis: Use
timeoutparameterCrawling: Reduce
maxPagesor increase delays
License
MIT
Available Tools
8 toolsanalyze_pageA
Analyze a single web page for SEO factors including:
Meta tags (title, description, canonical, robots)
Heading structure (H1-H6)
Structured data (JSON-LD, with special focus on JobPosting schema)
JavaScript rendering analysis (CSR vs SSR detection)
Link analysis (internal, external, nofollow)
Image analysis (alt tags, lazy loading)
Mixed content detection
Basic load time measurement
Use this for detailed analysis of specific pages like job detail pages, landing pages, or homepage.
Inputs: url (required), waitForSelector, timeout, device.
analyze_sitemapA
Analyze a site's robots.txt and XML sitemaps.
Returns:
robots.txt rules and any blocking issues
All discovered sitemaps (from robots.txt and common locations)
URL counts and job-specific URL detection
Sitemap freshness analysis
Recommendations for job boards (Indexing API, job sitemaps)
Use this as a first step to understand site structure before crawling.
Inputs: baseUrl (required), includeSitemapUrls, maxUrls.
check_urlsA
Check HTTP status codes for a list of URLs.
Returns status code, redirect destination (if redirected), and response time for each URL.
Use this to:
Verify expired job pages are handled correctly
Check for broken links
Analyze redirect chains
Inputs: urls (required), timeout.
crawl_siteA
Crawl multiple pages of a website starting from a URL. Discovers internal links and analyzes each page.
Returns:
Aggregated statistics (pages with titles, meta descriptions, schema, etc.)
Page type classification (job detail, category landing, location pages, etc.)
Duplicate detection (titles, descriptions)
Critical issues and warnings
All individual page analyses
Use this for comprehensive site audits. Respects crawl limits and delays.
Inputs: startUrl (required), maxPages, maxDepth, includePatterns, +1 more.
plan_auditA
RECOMMENDED FIRST STEP - Analyze sitemaps and create an intelligent sampling strategy for large sites.
This tool is essential for job boards and large sites with 100k+ pages. Instead of crawling everything, it:
Discovers and validates all sitemaps (robots.txt + common locations)
Identifies distinct route patterns (job pages, category pages, location pages, etc.)
Estimates total pages per route type
Generates a smart sampling strategy
Recommends which pages to analyze with Lighthouse
Returns:
Sitemap validation (URL limits, lastmod coverage, compression)
Route pattern classification with estimated counts
Sampling strategy (how many pages to sample per type)
Issues, warnings, and recommendations
Use this BEFORE crawl_site or sample_pages to understand site structure.
Inputs: baseUrl (required), maxSitemapsToProcess, maxUrlsPerSitemap.
run_auditA
FULL AUDIT - Run a complete SEO audit with automatic sampling, caching, and report generation.
This is the main audit tool that orchestrates the entire workflow:
Discovers and analyzes sitemaps
Identifies route patterns and creates sampling strategy
Captures sample pages (cached - only fetches once)
Analyzes SEO, structured data, technical issues, social graph
Generates prioritized recommendations
Saves everything to reports/[sitename]/ folder
The audit captures pages ONCE and stores:
HTML snapshots for inspection
Full analysis data as JSON
Final report as JSON + Markdown
Returns comprehensive findings and prioritized fix recommendations.
Inputs: baseUrl (required), reportsDir, maxSitemaps, maxUrlsPerSitemap, +2 more.
run_lighthouseA
Run a Lighthouse performance audit on a URL.
Returns:
Performance, Accessibility, Best Practices, and SEO scores
Core Web Vitals (LCP, CLS, TBT/INP proxy, FCP, TTFB)
Optimization opportunities with estimated savings
Diagnostics (long tasks, layout shifts, etc.)
SEO audit results (crawlability, meta tags, etc.)
Use this for performance analysis. Run separately for mobile and desktop if both matter.
Note: Requires Lighthouse CLI to be installed (npm install -g lighthouse).
Inputs: url (required), device, categories, saveReport.
sample_pagesA
Intelligently sample and analyze pages based on an audit plan.
Use this AFTER plan_audit to analyze representative pages from each route type.
For a site with 500k job pages, instead of crawling all of them, this will:
Sample 30-50 job detail pages (random + oldest + newest)
Sample 10-20 category landing pages
Sample 10-20 location pages
Sample company pages, static pages, etc.
Returns:
Detailed analysis of each sampled page
Aggregated issues per route type
Cross-cutting findings (% missing titles, schema errors, etc.)
Common issues ranked by frequency
This approach finds template-level issues that affect all pages of that type.
Inputs: plan (required), routeTypes, samplesOverride, concurrency.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Most tools have distinct purposes, but there is some overlap between crawl_site, run_audit, and sample_pages. crawl_site performs comprehensive crawling and analysis, run_audit orchestrates a full audit including sampling, and sample_pages focuses on intelligent sampling after planning. While their descriptions clarify differences, an agent might initially confuse when to use crawl_site versus run_audit, as both involve crawling and analysis, though run_audit is more automated and includes caching and reporting.
Tool names follow a consistent verb_noun pattern (e.g., analyze_page, check_urls, crawl_site), with minor deviations. The main inconsistency is run_lighthouse, which uses 'run' instead of 'analyze' or 'check', and run_audit, which also uses 'run' but fits the pattern. Overall, the naming is predictable and readable, with only slight variations in verb choice.
With 8 tools, the count is well-scoped for an SEO audit server. Each tool serves a specific function in the audit workflow, from initial planning (plan_audit) to detailed analysis (analyze_page) and comprehensive auditing (run_audit). The tools cover a range of tasks without being overwhelming, and none feel redundant or unnecessary given the domain's complexity.
The tool set provides complete coverage for SEO auditing, including planning (plan_audit), crawling (crawl_site), sampling (sample_pages), detailed analysis (analyze_page, run_lighthouse), sitemap handling (analyze_sitemap), URL checking (check_urls), and full automation (run_audit). There are no obvious gaps; the tools support a full lifecycle from initial assessment to report generation, with clear workflows and no dead ends for agents.
Maintenance
Related MCP Connectors
Technical SEO and AI-readiness audits for any page, plus a check that your fix worked.
Professional SEO auditing: 15 tools, 9 checks, CWV, E-E-A-T, schema, GEO. Free tier.
Technical SEO + GEO (AI-search) site audits: hosted crawls, prioritized fixes, report diffs.
Technical SEO audits: check a page or crawl a whole site, locally or hosted. Compares crawls.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA comprehensive MCP server for SEO, performance, GEO, and UX audits with 37 tools covering technical SEO, Lighthouse performance, AI search optimization, content analysis, accessibility, security, and more.1MIT
- FlicenseNot gradedqualityCmaintenanceAudits any website for SEO issues, providing scored health checks, schema validation, and performance analysis through AI assistants.-
- FlicenseNot gradedqualityNot gradedmaintenanceProvides comprehensive technical SEO audits, Schema.org validation, AEO readiness checks, and semantic cannibalization detection via MCP and CLI.-
- FlicenseNot gradedqualityNot gradedmaintenanceEnables natural language technical and JavaScript SEO audits, including headless rendering, hydration gap analysis, schema validation, AEO checks, and semantic cannibalization detection.1-