Skip to main content
Glama
SEO Audit MCP Server

SEO Audit MCP Server

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 build

Configure 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 analysis

crawl_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 warnings

run_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
- Diagnostics

analyze_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
- Recommendations

check_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 URL

Usage 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:

  1. JobPosting Schema Validation

    • Validates all required fields (title, description, datePosted, etc.)

    • Checks recommended fields (validThrough, baseSalary, employmentType)

    • Remote job validation (applicantLocationRequirements)

    • Expiration date checking

  2. 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

  3. Expired Job Handling Analysis

    • Detects 404s, redirects, and soft 404s

    • Checks validThrough dates in schema

    • Recommends proper handling strategies

  4. 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 lint

Architecture

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 utilities

Troubleshooting

Playwright Issues

# Reinstall browsers
npx playwright install chromium --force

# On Linux, you may need system dependencies
npx playwright install-deps

Lighthouse Not Found

# Install globally
npm install -g lighthouse

# Or use npx (slower)
npx lighthouse --version

Permission Errors

The server needs to write to /tmp for temporary files. Ensure proper permissions.

Timeout Errors

For slow sites, increase timeouts:

  • Page analysis: Use timeout parameter

  • Crawling: Reduce maxPages or increase delays

License

MIT

Available Tools

8 tools
analyze_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:

  1. Discovers and validates all sitemaps (robots.txt + common locations)

  2. Identifies distinct route patterns (job pages, category pages, location pages, etc.)

  3. Estimates total pages per route type

  4. Generates a smart sampling strategy

  5. 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:

  1. Discovers and analyzes sitemaps

  2. Identifies route patterns and creates sampling strategy

  3. Captures sample pages (cached - only fetches once)

  4. Analyzes SEO, structured data, technical issues, social graph

  5. Generates prioritized recommendations

  6. 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

    A4.1/5.0

    Scored across 8 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count5/5

    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.

    Completeness5/5

    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

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A 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.
      1
      MIT
    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      Provides comprehensive technical SEO audits, Schema.org validation, AEO readiness checks, and semantic cannibalization detection via MCP and CLI.
      -
    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      Enables natural language technical and JavaScript SEO audits, including headless rendering, hydration gap analysis, schema validation, AEO checks, and semantic cannibalization detection.
      1
      -