seo-geo-mcp-server
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-geo-mcp-server Check if ChatGPT can cite example.com"
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-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.
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
GPTBotstops training. BlockingOAI-SearchBotstops 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,PerplexityBotandCCBotlargely 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 |
| One fetch → seven weighted sections (meta, headings, content, schema, images, links, crawlability) → 0–100 score, A–F grade, prioritised fixes. |
| 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 |
| 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 |
| Whether content survives without JavaScript — detects unhydrated SPA shells that AI crawlers cannot read |
| Detects and validates |
On-page
Tool | What it does |
| Title, description, canonical, robots (meta and |
| Open Graph + Twitter Card, and verifies the |
| Full h1–h6 outline, multiple h1s, skipped levels, question-shaped headings |
| JSON-LD/microdata/RDFa extraction, parse errors, and Google rich-result requirements for 21 schema types |
| Word count, Flesch reading ease, thin-content detection, text-to-HTML ratio, term density (EN + ES stopwords) |
| Missing alt text, missing dimensions (layout shift), lazy loading, WebP/AVIF adoption |
Technical
Tool | What it does |
| RFC 9309 parse; flags wildcard |
| Discovery via robots.txt → conventional paths; index following, gzip, 50k/50MiB limits, |
| All four http/https × apex/www variants — do they converge on one canonical URL, and via 301 or 302? |
| Hop-by-hop chain with loop and temporary-redirect detection |
| Internal/external split, rel attributes, generic anchor text, optional broken-link sampling |
| 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.txtis 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 — andgeo_auditdeliberately does not score it. (llms-full.txtis a docs-tooling convention, not part of the proposal.)Some robots.txt blocks are advisory.
Perplexity-User,ChatGPT-Userandmeta-externalfetcherare 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-serverUse 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 /healthzIt 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 |
|
|
|
|
| Listening port |
|
| Bind address; |
| — | Comma-separated hostnames the |
| — | Comma-separated origins allowed to call from a browser |
| — | If set, every request needs |
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-mcpDevelop
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 toolsai_crawler_accessAI Crawler Access CheckARead-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:
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.
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.
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 CheckARead-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 AnalysisARead-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 AuditARead-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 StructureARead-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 CheckARead-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 CheckARead-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
link_auditLink AuditARead-onlyIdempotent
Audit a page's outbound links: the internal/external split, rel attributes (nofollow, sponsored, ugc), links with no anchor text at all, generic anchor text ("click here", "leer más") that carries no topical signal, and the distribution of external domains. Optionally sample-verifies that links actually resolve, retrying with GET when a server rejects HEAD.
Args:
url (string): the page to audit.
check_broken (boolean): verify links resolve (default false).
sample_size (number): how many links to verify (default 25).
response_format ('markdown' | 'json'): output format (default 'markdown').
Returns: { total_links, internal_links, external_links, nofollow_links, empty_anchor_text, generic_anchor_text[], external_domains[{domain, count}], checked_count, broken[], score, grade, findings[] }.
Example: "Are there broken links on https://example.com/resources?" -> link_audit(url="https://example.com/resources", check_broken=true).
Inputs: url (required), sample_size, check_broken, response_format. Returns: url, grade, score, broken, +12 more
llms_txt_checkllms.txt CheckARead-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 CheckARead-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 TraceARead-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 CheckARead-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 CheckARead-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 AuditARead-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 CheckARead-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
structured_data_checkStructured Data (Schema.org) CheckARead-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
Scored across 17 tools
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).
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.
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.
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
Related MCP Connectors
Free MCP server that audits any public URL: technical SEO, Core Web Vitals, indexing checks.
Open-source AI SEO over MCP: audits, ranks, keywords, backlinks + AI visibility (GEO).
Unified 15-tool SEO, SERP, clean Markdown & GEO (LLM citation Share-of-Voice) MCP server.
Run SEO + AI-visibility (GEO) audits from Claude, Cursor & other AI clients.
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceMCP 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.-
- AlicenseNot gradedqualityBmaintenanceOpen-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).49MIT
- 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.182MIT

atomno-mcp-seo-auditofficial
AlicenseAqualityCmaintenanceMCP server for technical SEO audits, powered by the detail.web engine. Run a site audit straight from your AI agent to get a health score, issues across 8 categories, and a GEO sub-score.846 PyPI1MIT
social_preview_checkSocial Preview (Open Graph & Twitter Card) CheckARead-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