Skip to main content
Glama
seo-geo-mcp-server

seo-geo-mcp-server

by OrtaMarco

seo-geo-mcp-server

An MCP server that lets an AI agent audit a page for SEO and GEO (Generative Engine Optimization) — on-page tags, structured data, robots.txt, sitemaps, hreflang, and whether ChatGPT, Claude, Perplexity and Gemini can actually crawl and cite you. No API keys required.

ci npm MCP TypeScript License: MIT

Built on the v2 MCP SDK: the server speaks the 2026-07-28 protocol revision and still accepts 2025-era clients (Claude Desktop, Claude Code, Cursor) from the same factory — one build, both eras, nothing to configure.

Ask Claude "how is this page doing, and will AI assistants cite it?" and it runs a full audit and hands you a graded report with prioritised fixes — instead of you pasting a URL into six different web tools.

> Audit https://example.com/guide and tell me if ChatGPT can cite it

  seo_audit(url="https://example.com/guide", include_geo=true)

  Overall: A (92/100) · indexable: yes
    Meta tags & social preview   95 (A)
    Heading structure           100 (A)
    Structured data              75 (C)

  GEO readiness: B (85/100)
    ✅ AI crawler access        25/25
    ✅ Server-rendered content  20/20
    ❌ Authorship & entity       2/10
  1. Add author and Organization markup with `sameAs` links to official profiles.

Why this exists

Two gaps, one server.

The SEO gap: the on-page checkers are all web UIs. None of them let an agent run the audit, read the result and fix the code in the same loop.

The GEO gap: "generative engine optimization" tooling is mostly rank-tracking dashboards behind a subscription. The mechanics that actually decide whether an AI assistant can cite you are cheap to check and almost never checked:

  • Can the AI search crawlers reach you? Blocking GPTBot stops training. Blocking OAI-SearchBot stops you being cited. Most sites that meant to do the first have accidentally done the second. This server separates them.

  • Does your content exist without JavaScript? Googlebot renders JS. GPTBot, ClaudeBot, PerplexityBot and CCBot largely do not. A client-rendered page can rank fine in Google and be invisible to every AI assistant.

It is the agent-facing companion to the tools at ortamarco.me, and shares its core (the connect-time SSRF guard and host validation) with domain-security-mcp-server.

Related MCP server: librecrawl-technical-seo-audit-mcp

Tools

Audits

Tool

What it does

seo_audit ⭐

One fetch → seven weighted sections (meta, headings, content, schema, images, links, crawlability) → 0–100 score, A–F grade, prioritised fixes. include_geo=true adds the GEO dimension

geo_audit ⭐

AI answer-engine readiness: crawler access (25), server-rendered content (20), structured data (15), extractable structure (15), authorship (10), freshness (8), depth (7)

GEO

Tool

What it does

ai_crawler_access

Resolves ~35 AI crawler tokens against robots.txt. Separates training from citation bots, flags blocks that vendors document as unenforceable, handles the Applebot→Googlebot fallback

render_check

Whether content survives without JavaScript — detects unhydrated SPA shells that AI crawlers cannot read

llms_txt_check

Detects and validates /llms.txt against the llmstxt.org proposal — and reports its real adoption status rather than implying it earns visibility

On-page

Tool

What it does

meta_tags_check

Title, description, canonical, robots (meta and X-Robots-Tag), lang, charset, viewport

social_preview_check

Open Graph + Twitter Card, and verifies the og:image actually loads

heading_structure

Full h1–h6 outline, multiple h1s, skipped levels, question-shaped headings

structured_data_check

JSON-LD/microdata/RDFa extraction, parse errors, and Google rich-result requirements for 21 schema types

content_analysis

Word count, Flesch reading ease, thin-content detection, text-to-HTML ratio, term density (EN + ES stopwords)

image_seo_check

Missing alt text, missing dimensions (layout shift), lazy loading, WebP/AVIF adoption

Technical

Tool

What it does

robots_txt_check

RFC 9309 parse; flags wildcard Disallow: / and 5xx responses (which Google reads as disallow-all)

sitemap_check

Discovery via robots.txt → conventional paths; index following, gzip, 50k/50MiB limits, lastmod validity

canonical_host_check

All four http/https × apex/www variants — do they converge on one canonical URL, and via 301 or 302?

redirect_trace

Hop-by-hop chain with loop and temporary-redirect detection

link_audit

Internal/external split, rel attributes, generic anchor text, optional broken-link sampling

hreflang_check

BCP-47 validity, self-reference, x-default, duplicates — plus optional reciprocity verification

Every tool is read-only, declares an outputSchema and returns structuredContent (validated by the SDK) alongside human-readable Markdown (default) or JSON (response_format="json"), plus actionable error messages.

Honesty notes

This server deliberately refuses to overstate two things that most GEO content gets wrong. Both are surfaced in tool output, not buried here:

  • llms.txt is not an adopted standard. It is a community proposal from September 2024. No major AI vendor has documented that its crawlers read it from third-party sites, and Google has publicly said it does not. The tool reports presence and validates shape — and geo_audit deliberately does not score it. (llms-full.txt is a docs-tooling convention, not part of the proposal.)

  • Some robots.txt blocks are advisory. Perplexity-User, ChatGPT-User and meta-externalfetcher are documented by their own vendors as ignoring or possibly ignoring robots.txt. Reporting those as cleanly "blocked" would be misleading, so they are listed separately as unenforceable.

Crawler tokens carry a provenance field distinguishing first-party vendor documentation from community aggregators, and vendors that publish no token at all (xAI/Grok, Microsoft Copilot) are named explicitly — because a missing rule cannot be read as either allowed or blocked.

Install

Requires Node.js 20.18+. Nothing to clone — every MCP client can run it with npx.

Use it with Claude Code

claude mcp add seo-geo -- npx -y seo-geo-mcp-server

Use it with Claude Desktop or Cursor

Add to claude_desktop_config.json (or ~/.cursor/mcp.json) — see examples/:

{
  "mcpServers": {
    "seo-geo": {
      "command": "npx",
      "args": ["-y", "seo-geo-mcp-server"]
    }
  }
}

On Windows use "command": "cmd" with "args": ["/c", "npx", "-y", "seo-geo-mcp-server"]. Restart the client, then ask: "Audit the SEO and GEO of example.com."

Self-host (HTTP transport)

The same server speaks stateless Streamable HTTP for remote or multi-client use. One endpoint serves both protocol eras; there is no session state and no Mcp-Session-Id to carry.

TRANSPORT=http npx -y seo-geo-mcp-server
# POST JSON-RPC to http://127.0.0.1:3000/mcp   ·   health at /healthz

It is safe by default: it binds to 127.0.0.1 and only accepts localhost Host and Origin headers, which blocks DNS-rebinding attacks from a web page. To expose it — for example behind Coolify or Traefik — opt in explicitly:

Variable

Default

Purpose

TRANSPORT

stdio

http to serve Streamable HTTP

PORT

3000

Listening port

HOST

127.0.0.1

Bind address; 0.0.0.0 to accept remote connections

ALLOWED_HOSTS

—

Comma-separated hostnames the Host header may carry (e.g. mcp.example.com)

ALLOWED_ORIGINS

—

Comma-separated origins allowed to call from a browser

MCP_AUTH_TOKEN

—

If set, every request needs Authorization: Bearer <token>

Binding to a non-loopback address without ALLOWED_HOSTS or MCP_AUTH_TOKEN works, but the server says so on stderr. With Docker (the image sets HOST=0.0.0.0):

docker build -t seo-geo-mcp .
docker run -p 3000:3000 -e ALLOWED_HOSTS=mcp.example.com -e MCP_AUTH_TOKEN=change-me seo-geo-mcp

Develop

npm run dev      # tsx watch (stdio)
npm test         # deterministic unit tests: SSRF guard, robots matcher, nesting guard,
                 # gzip sitemaps, SPA detection, JSON-LD, HTTP transport defaults
npm run smoke    # call all 17 tools over MCP, in BOTH protocol eras, and validate
                 # structuredContent vs outputSchema
npm run inspect  # open the MCP Inspector against the built server
npm run build    # type-check + emit dist/

evals/ holds a 10-question LLM evaluation set (stable, verifiable) and instructions for running it — see evals/README.md.

How it works

src/
├── index.ts        # transport selection: serveStdio | createMcpHandler + Express
├── server.ts       # the factory: registers every tool on one McpServer
├── schemas.ts      # Zod 4 outputSchema for each tool
├── core/           # pure logic, no MCP coupling — reusable & testable
│   ├── validate.ts     # host/URL validation and the address classifier
│   ├── netguard.ts     # connect-time SSRF guard (every socket's address is checked)
│   ├── fetch.ts        # fetch: guarded dispatcher, manual redirects, loop detection, byte caps
│   ├── page.ts         # HTML loading + the shared parsed-document model
│   ├── meta.ts         # title/description/canonical/robots, Open Graph, hreflang
│   ├── content.ts      # headings, readability, word counts, image SEO
│   ├── structured-data.ts # JSON-LD/microdata + Google rich-result requirements
│   ├── robots.ts       # RFC 9309 parser and rule matcher
│   ├── ai-crawlers.ts  # the AI crawler registry (token, purpose, compliance, provenance)
│   ├── sitemap.ts      # discovery, index following, gzip, protocol limits
│   ├── links.ts        # link classification + broken-link sampling
│   ├── redirects.ts    # chain tracing + host canonicalisation
│   ├── geo.ts          # llms.txt, JS-rendering detection, GEO scoring
│   └── seo-audit.ts    # the composite audits (one fetch, every analyser)
└── tools/          # thin MCP wrappers (Zod schemas, descriptions, formatting)

The core/ layer is deliberately free of any MCP types, so the same logic can power both this server and a web UI.

Security

The tools fetch URLs the caller names and URLs the audited site names (links, og:image, hreflang alternates, sitemap children, redirects), so every outbound connection is screened against server-side request forgery:

  • Private, loopback, link-local (cloud metadata), shared (CGNAT), multicast and reserved addresses are refused in every spelling, including IPv4 embedded in IPv6 ([::ffff:127.0.0.1]).

  • The check runs at connect time, on the address the socket is about to use, so DNS rebinding and names only an internal resolver knows are refused too. Redirects are followed by hand, every hop is screened, and loops are reported.

  • Untrusted input is bounded: 2 MB of HTML, 512 levels of nesting (what browsers keep), a backtracking-free robots.txt matcher, 10 MiB per sitemap (gzip output included), six link checks at a time, and at most 200 items per list in a result.

Found a problem? Please open a private security advisory.

License

MIT © Marco Orta

Available Tools

17 tools
ai_crawler_accessAI Crawler Access CheckA
Read-onlyIdempotent

Resolve every known AI/LLM crawler against a site's robots.txt and report which may fetch a given path. Covers OpenAI (GPTBot, OAI-SearchBot, ChatGPT-User, OAI-AdsBot), Anthropic (ClaudeBot, Claude-User, Claude-SearchBot), Google (Google-Extended, Googlebot, Google-CloudVertexBot), Perplexity, Apple, Meta, Amazon, Mistral, Common Crawl, ByteDance and others.

Three things this gets right that a naive robots.txt reader does not:

  1. Training vs citation. Blocking GPTBot stops training; blocking OAI-SearchBot stops you being cited in ChatGPT search. Most people want the first, not the second. Blocked citation-critical bots are called out separately.

  2. Which blocks are actually enforceable. Perplexity-User, ChatGPT-User and meta-externalfetcher are documented by their own vendors as ignoring or possibly ignoring robots.txt. A "blocked" verdict for those is advisory, and is reported as such rather than as a clean block.

  3. Vendor quirks. Apple documents that when robots.txt has no Applebot group but does have a Googlebot group, Applebot follows the Googlebot rules — so the effective verdict differs from the literal one.

Each crawler also carries its provenance: whether the token comes from first-party vendor documentation or only from community aggregators. Vendors that publish no crawler token at all (xAI/Grok, Microsoft Copilot) are listed separately, because absence of a rule cannot be read as allowed or blocked.

Args:

  • site (string): domain or any URL on it.

  • path (string): path to test (default '/').

  • include_deprecated (boolean): include retired tokens (default false).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { crawlers[{token, vendor, purpose, allowed, via_wildcard, matched_rule, respects_robots_txt, compliance_note, provenance, quirk}], allowed_count, blocked_count, blocked_citation_critical[], unenforceable_blocks[], undocumented_vendors[], findings[] }.

Example: "Can ChatGPT and Perplexity crawl example.com?" -> ai_crawler_access(site="example.com").

Inputs: site (required), path, response_format, include_deprecated. Returns: url, path, crawlers, findings, +6 more

canonical_host_checkCanonical Host CheckA
Read-onlyIdempotent

Fetch all four host/scheme variants of a domain — http/https × apex/www — and confirm they converge on a single canonical URL. Divergence is the classic cause of a homepage competing with itself in the index.

Also reports whether plain HTTP is upgraded to HTTPS, whether canonicalisation uses permanent (301/308) rather than temporary (302/307) redirects, and which variants do not serve content at all.

Args:

  • site (string): a domain such as 'example.com' (www and scheme are ignored).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { domain, variants[{variant, reachable, status, final_url, hop_count, redirect_statuses[]}], canonical_url, converges, distinct_endpoints[], forces_https, score, grade, findings[] }.

Example: "Do all versions of example.com redirect to one URL?" -> canonical_host_check(site="example.com").

Inputs: site (required), response_format. Returns: grade, score, domain, findings, +5 more

content_analysisContent Quality AnalysisA
Read-onlyIdempotent

Measure the page's main content: word count, sentence and paragraph counts, Flesch reading ease with a plain-language reading level, estimated reading time, text-to-HTML ratio, thin-content detection, and the top non-stopword terms with their density (English and Spanish stopwords are both filtered).

Content is read from the / landmark when present, so navigation and footer chrome do not inflate the counts.

Args:

  • url (string): the page to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { word_count, sentence_count, paragraph_count, avg_words_per_sentence, reading_ease, reading_level, reading_time_minutes, thin_content, text_to_html_ratio, used_content_landmark, top_terms[{term, count, density}], score, grade, findings[] }.

Example: "Is the content on https://example.com/post too thin?" -> content_analysis(url="https://example.com/post").

Inputs: url (required), response_format. Returns: url, grade, score, findings, +13 more

geo_auditGEO / AI Answer-Engine Readiness AuditA
Read-onlyIdempotent

Score how readily an AI answer engine (ChatGPT, Claude, Perplexity, Gemini, Copilot) can fetch, parse and cite this page. Weighted across: AI crawler access (25), server-rendered content (20), structured data (15), extractable structure (15), authorship & entity signals (10), freshness (8) and content depth (7).

Two things this catches that a classic SEO tool does not:

  • Pages that rank fine in Google but are invisible to AI assistants, because most AI crawlers do not execute JavaScript and the content only appears after hydration.

  • robots.txt rules that block AI search crawlers (OAI-SearchBot, Claude-SearchBot, PerplexityBot) — the ones that build citation indexes — as opposed to the training crawlers people usually mean to block.

Args:

  • url (string): the page to audit.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { geo{score, grade, signals[], top_recommendations[]}, rendering, crawler_access, llms_txt, robots }.

Example: "Is https://example.com/guide ready to be cited by ChatGPT?" -> geo_audit(url="https://example.com/guide"). Note: llms.txt presence is reported but deliberately NOT scored — it is a community proposal with no committed vendor support, and Google has stated it does not use it.

Inputs: url (required), response_format. Returns: geo, robots, llms_txt, rendering, +1 more

heading_structureHeading StructureA
Read-onlyIdempotent

Extract the full h1–h6 outline and evaluate it: how many h1s, whether levels are skipped (h2 followed by h4), empty heading tags, and how many headings are phrased as questions — the last being a strong signal for featured snippets and AI citations.

Args:

  • url (string): the page to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { headings[{level, text, skips_level}], h1_count, h1_text[], level_skips, empty_headings, question_headings[], outline, score, grade, findings[] }.

Example: "Show me the heading outline of https://example.com/guide" -> heading_structure(url="https://example.com/guide").

Inputs: url (required), response_format. Returns: url, grade, score, h1_text, +8 more

hreflang_checkHreflang CheckA
Read-onlyIdempotent

Validate a page's <link rel="alternate" hreflang> annotations: language/region code validity (BCP-47), the required self-referencing entry, the x-default fallback, and duplicate codes.

With check_reciprocity=true it fetches each alternate and confirms it links back to this page — non-reciprocal hreflang is silently ignored by Google, and it is impossible to detect from one page in isolation.

Args:

  • url (string): the page to check.

  • check_reciprocity (boolean): verify alternates link back (default false).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { declared_lang, entries[{hreflang, href, valid_code, is_self, reciprocates}], has_x_default, self_referencing, duplicate_codes[], invalid_codes[], findings[] }.

Example: "Is hreflang set up correctly on https://example.com/es/pagina?" -> hreflang_check(url="https://example.com/es/pagina", check_reciprocity=true).

Inputs: url (required), response_format, check_reciprocity. Returns: url, entries, findings, final_url, +6 more

image_seo_checkImage SEO CheckA
Read-onlyIdempotent

Audit every on the page: missing alt attributes (an accessibility failure and a lost image-search signal), decorative alt="" usage, missing width/height (which causes layout shift, a Core Web Vitals factor), lazy-loading adoption, and how many images use modern formats (WebP/AVIF) versus legacy JPEG/PNG. sources are counted as modern delivery.

Args:

  • url (string): the page to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { total_images, missing_alt, decorative_alt, missing_dimensions, lazy_loaded, modern_format, legacy_format, images[], score, grade, findings[] }.

Example: "Which images on https://example.com are missing alt text?" -> image_seo_check(url="https://example.com").

Inputs: url (required), response_format. Returns: url, grade, score, images, +9 more

llms_txt_checkllms.txt CheckA
Read-onlyIdempotent

Check whether a site publishes /llms.txt and validate it against the llmstxt.org proposal: a required H1 title, an optional blockquote summary, and H2-delimited lists of - [name](url): notes links. Also detects /llms-full.txt.

Important context this tool always reports: llms.txt is a community proposal from September 2024, not an adopted standard. No major AI vendor has documented that its crawlers read llms.txt from third-party sites, and Google has publicly stated it does not support it. Publishing one is cheap and may help human readers and some documentation tooling, but it does not earn AI visibility on its own — robots.txt access, structured data and server-rendered content do. Note also that llms-full.txt is a de-facto convention popularised by docs tooling, not part of the proposal.

Use this tool to answer "do they publish one, and is it well-formed?" — not as evidence that a site is or is not AI-optimised.

Args:

  • site (string): domain or any URL on it.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { found, status, full_variant_found, bytes, title, has_summary_blockquote, sections[], link_count, spec_compliant, adoption_status, findings[] }.

Example: "Does example.com publish an llms.txt?" -> llms_txt_check(site="example.com").

Inputs: site (required), response_format. Returns: url, bytes, found, title, +9 more

meta_tags_checkMeta Tags CheckA
Read-onlyIdempotent

Inspect a page's head tags: title, meta description, canonical, robots directives (meta AND the X-Robots-Tag header), html lang, charset, viewport and favicon. Flags length problems, missing or duplicated tags, and anything that makes the page non-indexable.

Args:

  • url (string): the page to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { title, title_length, description, description_length, canonical, canonical_is_self, meta_robots, x_robots_tag, indexable, followable, lang, charset, viewport, score, grade, findings[] }.

Example: "Are the meta tags on https://example.com correct?" -> meta_tags_check(url="https://example.com").

Inputs: url (required), response_format. Returns: url, lang, grade, score, +16 more

redirect_traceRedirect TraceA
Read-onlyIdempotent

Follow a URL's redirect chain hop by hop, reporting each status code and target. Flags long chains (which waste crawl budget), redirect loops, temporary 302/307 redirects where a permanent 301/308 belongs, and chains that do not end on HTTPS.

Args:

  • url (string): the starting URL.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { final_url, final_status, hops[{url, status, location}], hop_count, https_upgrade, ends_https, has_loop, has_temporary_redirect, elapsed_ms, findings[] }.

Example: "Where does http://example.com/old-page end up?" -> redirect_trace(url="http://example.com/old-page").

Inputs: url (required), response_format. Returns: url, hops, findings, has_loop, +7 more

render_checkJavaScript Rendering CheckA
Read-onlyIdempotent

Determine whether a page's content exists in the server HTML, or only appears after JavaScript runs.

This matters more for AI visibility than for classic SEO: Googlebot renders JavaScript, but GPTBot, ClaudeBot, PerplexityBot and CCBot largely do not. A client-rendered page can rank perfectly well in Google and still be completely invisible to every AI assistant — this tool is how you catch that.

Detects unhydrated SPA shells (empty #root / #app / #__next containers), reports how many words survive without JS, and flags documents dominated by inline script bytes.

Args:

  • url (string): the page to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { renders_without_js, server_text_words, script_bytes, html_bytes, spa_shell_detected, framework_hint, findings[] }.

Example: "Can ChatGPT actually read https://example.com/app?" -> render_check(url="https://example.com/app").

Inputs: url (required), response_format. Returns: findings, html_bytes, script_bytes, framework_hint, +3 more

robots_txt_checkrobots.txt CheckA
Read-onlyIdempotent

Fetch and parse a site's robots.txt per RFC 9309. Reports every user-agent group with its Allow/Disallow rules, the declared sitemaps, and any lines that could not be parsed. Flags the two failures that silently deindex a site: a wildcard Disallow: /, and a robots.txt that returns 5xx (which Google treats as "disallow everything").

Args:

  • site (string): domain or any URL on it, e.g. 'example.com'.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { found, status, group_count, sitemaps[], blocks_everything, groups[{agents[], rules[], crawl_delay}], parse_warnings[], findings[] }.

Example: "What does example.com's robots.txt allow?" -> robots_txt_check(site="example.com"). For AI-crawler specifics use ai_crawler_access instead — it resolves each known AI bot against these rules.

Inputs: site (required), response_format. Returns: url, found, groups, status, +5 more

seo_auditFull On-Page SEO AuditA
Read-onlyIdempotent

Fetch a page once and audit it across seven weighted sections — meta tags & social preview, heading structure, content quality, structured data, image SEO, links and crawlability — returning a 0–100 score, an A–F grade and a prioritised fix list.

This is the tool to start with for any "how is this page doing for SEO?" question; drill into the single-purpose tools afterwards for detail.

Args:

  • url (string): the page to audit.

  • include_geo (boolean): also score AI answer-engine readiness (default false).

  • check_broken_links (boolean): sample-verify that links resolve (default false).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { score, grade, indexable, sections[{id, label, score, grade, weight, issues[]}], top_recommendations[], geo, findings[] }.

Example: "Audit the SEO of https://example.com/pricing" -> seo_audit(url="https://example.com/pricing"). Note: a noindex page or a site-wide robots.txt block caps the score, because nothing else matters until that is fixed. Errors: returns an error if the URL is unreachable, non-HTML, or returns an HTTP error.

Inputs: url (required), include_geo, response_format, check_broken_links. Returns: geo, url, grade, score, +8 more

sitemap_checkXML Sitemap CheckA
Read-onlyIdempotent

Discover, fetch and validate an XML sitemap. Finds it via the robots.txt Sitemap: directive, then falls back to /sitemap.xml, /sitemap_index.xml and /sitemap-index.xml. Handles sitemap indexes (following children) and gzipped sitemaps.

Validates: URL count against the 50,000 limit, uncompressed size against 50 MiB, presence and W3C-datetime validity, URLs pointing off-origin, http:// URLs, and duplicates.

Args:

  • site (string): domain or any URL on it.

  • sitemap_url (string, optional): explicit sitemap URL.

  • follow_children (number): child sitemaps of an index to follow (default 3).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { found, type, url_count, child_sitemaps[], with_lastmod, invalid_lastmod[], newest_lastmod, off_origin_urls[], exceeds_url_limit, discovered_via, score, grade, findings[] }.

Example: "Check the sitemap for example.com" -> sitemap_check(site="example.com").

Inputs: site (required), sitemap_url, follow_children, response_format. Returns: url, type, bytes, found, +18 more

social_preview_checkSocial Preview (Open Graph & Twitter Card) CheckA
Read-onlyIdempotent

Validate the tags that build link-preview cards on X, LinkedIn, Facebook, Slack, WhatsApp and Discord: og:title, og:description, og:image, og:url, og:type, og:site_name and the twitter:* family. Optionally verifies the preview image actually loads, and flags the classic bug of a relative og:image URL (social scrapers require absolute URLs).

Args:

  • url (string): the page to check.

  • check_image (boolean): verify the og:image resolves (default true).

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { open_graph{}, twitter{}, og_image_url, og_image_reachable, og_image_status, score, grade, findings[] }.

Example: "Why does my link preview look broken on LinkedIn?" -> social_preview_check(url="https://example.com/post").

Inputs: url (required), check_image, response_format. Returns: url, grade, score, twitter, +7 more

structured_data_checkStructured Data (Schema.org) CheckA
Read-onlyIdempotent

Extract and validate JSON-LD, microdata and RDFa. Reports every @type found, flags JSON-LD blocks that fail to parse (those are invisible to search engines), and checks recognised types against Google's rich-result requirements — required properties that are missing, plus recommended ones worth adding.

Covers Article/BlogPosting/NewsArticle, Product, FAQPage, HowTo, Recipe, Event, Organization, LocalBusiness, Person, WebSite, BreadcrumbList, VideoObject, JobPosting, Course, Review and AggregateRating.

Args:

  • url (string): the page to check.

  • response_format ('markdown' | 'json'): output format (default 'markdown').

Returns: { json_ld_blocks, microdata_items, parse_errors[], items[{type, properties[], missing_required[], missing_recommended[], valid}], types_found[], has_organization, has_breadcrumb, score, grade, findings[] }.

Example: "Does https://example.com/product have valid Product schema?" -> structured_data_check(url="https://example.com/product").

Inputs: url (required), response_format. Returns: url, grade, items, score, +13 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 17 tools

    Disambiguation5/5

    Each tool targets a distinct SEO/geo concern: robots.txt, AI crawler access, llms.txt, page rendering, meta tags, social preview, headings, structured data, content, images, sitemap, links, hreflang, redirects, and canonical host. No two tools overlap; even the closely related robots_txt_check and ai_crawler_access are clearly differentiated by scope (all bots vs. AI bots).

    Naming Consistency5/5

    All tools follow a consistent snake_case verb_noun pattern: robots_txt_check, seo_audit, geo_audit, ai_crawler_access, llms_txt_check, render_check, meta_tags_check, social_preview_check, heading_structure, structured_data_check, content_analysis, image_seo_check, sitemap_check, link_audit, hreflang_check, redirect_trace, canonical_host_check. Naming clearly indicates what each tool does with no convention mixing.

    Tool Count4/5

    At 17 tools, the set is on the heavier side but appropriate for a comprehensive SEO/geo audit server covering a wide range of technical checks. The count is justified by the breadth of the domain; no tool feels redundant or trivial.

    Completeness4/5

    The server covers the major technical SEO and AI-visibility surfaces: robots.txt, rendering, meta tags, social preview, headings, structured data, content quality, images, sitemaps, links, hreflang, redirects, and canonicalization. Minor gaps exist (e.g., no tool for keyword research, backlink analysis, or mobile usability), but these fall outside the apparent scope of a technical/geo audit server.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      MCP server for website SEO + GEO analysis. Scan any URL to get scores across 5 categories (SEO, GEO, Performance, Security, Accessibility) with actionable fix recommendations. Enables AI coding assistants to audit websites and implement fixes autonomously.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Open-source technical SEO crawler MCP server built on LibreCrawl. Runs full audits inside Claude, Cursor, or Codex — 50+ checks (hreflang, schema.org, security headers, WAF detection on 200-OK pages), chunked-progressive engine for large sites, ephemeral by design (server forgets every audit after download).
      49
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables 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.
      18
      2
      MIT