# SEO Authority Prover MCP

> SEO Authority Prover checks if AI-generated content actually works in modern search engines. It validates HTML structure, ensures structured data matches reality, and tests for SpamBrain compliance across five key axes: E-E-A-T demonstration, technical foundation (INP/LCP), Generative Engine Optimization (GEO) for citations, and Answer Engine Optimization (AEO).

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** seo-expert, spambrain, eeat, generative-engine-optimization, answer-engine-optimization, core-web-vitals, schema-markup, google-algorithm, agentic-pipeline

## Description

You're dealing with search engines that don't just read content; they parse code and structural intent. When you hit publish, your page has to be airtight—structurally perfect from top to bottom. The SEO Authority Prover runs a full audit against what modern AI clients actually look for. It checks if the deep mechanics of your HTML are clean, if the structured data you added matches what users see, and whether your content is built to withstand advanced algorithmic scrutiny.

When you use `validate_html_semantic`, it doesn't just glance at your page; it runs a full structural check. It verifies proper usage of semantic tags like `<article>` or `<section>`, confirming everything adheres to current web standards. You can tell it'll check the title length and ensure your heading hierarchy follows strict rules, moving correctly from H1 down through H2s and subsequent levels. Furthermore, this tool audits critical performance elements—it tests for things like Largest Contentful Paint (LCP) and Interaction to Next Paint (INP), making sure you meet 2026 technical thresholds right out of the gate.

If your page uses structured markup, `validate_jsonld_ai` makes sure it's telling the truth. It verifies that every piece of JSON-LD data you added accurately reflects the content visible on the actual page. This is crucial because mismatching data can trigger validation errors and hurt your authority signal. The tool also confirms proper entity linking using `@graph/@id`, guaranteeing search engines understand how all your parts connect.

The big picture audit comes from `validate_seo_authority`. It’s where everything ties together, checking for SpamBrain compliance while confirming E-E-A-T demonstration isn't just a claim but is actually structured into the content. This single tool audits Core Web Vitals standards alongside much more complex signals: it checks your Generative Engine Optimization (GEO) structure by advising you on how to include statistics every 150 to 200 words and using question-based headings for maximum citation boost. It also enforces Answer Structure (AEO), formatting content into answer-first blocks that are perfect for AI Overviews and other generative search platforms. You'll never have to worry about whether your code or strategy is going to fail before you hit publish; this server tells you exactly where the structural gaps are, ensuring your page performs across technical foundations, citation readiness, and overall authority.

## Tools

### validate_seo_authority
Performs an overall audit, checking for SpamBrain compliance, E-E-A-T demonstration, Core Web Vitals standards, GEO citation structure, and AEO readiness.

### validate_html_semantic
Checks HTML tags, meta descriptions, heading hierarchy, and performance elements (LCP/INP) for structural perfection.

### validate_jsonld_ai
Validates structured JSON-LD data to ensure it matches visible content and uses proper entity linking (@graph/@id).

## Prompt Examples

**Prompt:** 
```
We need to optimize our blog for SEO. We should use the keyword 'best project management software' at least 5 times in each article, put it in every heading, and create 100 articles targeting variations of this keyword.
```

**Response:** 
```
Verdict: SPAMBRAIN_FLAGGED. Triple violation. (1) 'Use keyword 5 times in each article, in every heading' is KEYWORD STUFFING — the #1 pattern SpamBrain ML detects. Keyword density should be under 1-2%, used naturally. (2) '100 articles targeting variations' is SCALED CONTENT ABUSE — mass-producing pages without unique user value. The March 2026 Spam Update specifically targets this. (3) No mention of user intent, original insight, or information gain. Modern SEO uses semantic rel...
```

**Prompt:** 
```
Content: pillar page on 'Project Management Methodologies' supported by 12 cluster articles. SpamBrain: keyword density 0.8%, no exact-match anchors, all backlinks from editorial mentions in PM industry publications. E-E-A-T: author is PMP-certified PM with 15 years at Fortune 500, includes original survey data from 200 PMs, cited by PMI.org 3 times. Technical: self-referencing canonicals, JSON-LD @graph (Organization + WebSite + Article + FAQPage + BreadcrumbList with @id linking...
```

**Response:** 
```
Verdict: SEO_PROVEN. SpamBrain-safe (0.8% density, editorial links, unique survey data). E-E-A-T demonstrated (PMP certification, 15-year experience, original research, PMI citations). Technically sound (LCP 1.8s, INP 120ms, CLS 0.04 — all passing, JSON-LD @graph with entity linking). GEO-optimized (original statistics every ~180 words, expert quotes, modular autonomous sections). AEO-ready (50-word atomic answers, entity consistency, FAQPage schema, conversational tone). This str...
```

**Prompt:** 
```
We have great content but our site loads slowly (LCP 4.2s, INP 380ms) and we don't use any schema markup. Our canonical tags point to different URLs than our internal links.
```

**Response:** 
```
Verdict: TECHNICALLY_BROKEN. Triple failure. (1) LCP 4.2s (target <2.5s) — hero images likely not optimized (use WebP/AVIF, avoid lazy-loading LCP element, use CDN). (2) INP 380ms (target <200ms) — this is the CRITICAL 2026 metric. Long JavaScript tasks are blocking the main thread. Split tasks, defer third-party scripts (analytics, chat, ads), avoid synchronous DOM updates. (3) Canonical/internal link mismatch — this sends CONFLICTING signals to Google. Canonicals, internal links...
```

## Capabilities

### Validate HTML Structure
Checks title length, heading hierarchy (H1→H2), and semantic element usage against current web standards.

### Verify Schema Data Links
Confirms that your structured JSON-LD data accurately reflects the content visible on the page, preventing validation errors.

### Test Core Web Vitals Compliance
Audits technical metrics like Largest Contentful Paint (LCP) and Interaction to Next Paint (INP) against 2026 thresholds.

### Check SpamBrain Safety
Scans for keyword stuffing, unnatural link patterns, or scaled content abuse that modern ML algorithms detect.

### Optimize for AI Citation
Restructures the page to boost citation rates by including statistics every 150-200 words and using question-based headings (GEO).

### Enforce Answer Structure
Formats content into answer-first blocks, perfect for AI Overviews and other generative search platforms (AEO).

## Use Cases

### Fixing an outdated blog template
A developer updates a legacy article. Instead of just adding new copy, the agent runs `validate_html_semantic` and sees that all the images are using 'lazy-load' on the hero element. It flags this as LCP failure, forcing the fix (using WebP/AVIF and eager loading) before the content goes live.

### Validating a complex data page
The marketing team creates an article with author credentials, dates, and pricing tables. Running `validate_jsonld_ai` immediately catches that the schema says 'Staff Writer' but the visible byline is 'Jane Chen, CTO,' flagging a critical content mismatch error.

### Auditing for AI search visibility
A strategist writes deep-dive research. Before publishing, they run `validate_seo_authority`. The tool identifies that the article is too narrative and needs statistics every 150-200 words and question-based headers to be visible in Generative Engine Overviews.

### Debugging technical debt
A site has multiple `<script type="application/ld+json">` blocks. `validate_jsonld_ai` finds entity fragmentation and forces the developer to consolidate all data into a single `@graph` array, creating proper knowledge graph connections.

## Benefits

- Stop worrying about basic tags. `validate_html_semantic` forces you to use correct HTML5 semantic elements, eliminating the risk of 'div soup' and ensuring screen readers interpret your page correctly.
- Guarantee machine context with `validate_jsonld_ai`. It checks for content mismatch—the most common error that makes search engines distrust your data. Schema must match reality.
- Keep your site fast. The tool enforces 2026 performance standards, checking LCP and INP thresholds so hero images don't destroy Core Web Vitals.
- Beat SpamBrain. Running `validate_seo_authority` prevents keyword stuffing and unnatural linking patterns that ML algorithms flag instantly, keeping you safe from algorithmic drops.
- Get cited by AI. It structures content using modular sections and source citations (GEO), boosting your chance of appearing in AI Overviews with proven methods.

## How It Works

The bottom line is: it forces you to build pages that survive the next generation of search algorithms by checking code structure, data reality, and authority signaling simultaneously.

1. Feed the server your page's source code or draft content. The agent first runs `validate_html_semantic` to ensure all core tags, performance metrics (LCP/INP), and basic structure are sound.
2. Next, it uses `validate_jsonld_ai` to build a semantic map. This process validates that every piece of structured data (like author names or prices) matches the text visible on the page.
3. Finally, it runs the full `validate_seo_authority` check. This step combines all findings—checking for E-E-A-T signals, SpamBrain violations, and GEO/AEO readiness—and outputs a comprehensive report detailing every required fix.

## Frequently Asked Questions

**Does this tool generate SEO content?**
No. The agent generates the SEO strategy and content. The tool VALIDATES that the strategy covers all dimensions of modern search excellence: SpamBrain compliance, E-E-A-T demonstration, technical foundation, GEO for AI citation, and AEO for answer engines. It catches the five failure modes that cause AI-generated SEO to fail.

**What is SpamBrain and why does it matter?**
SpamBrain is Google's ML-powered spam detection system. Unlike older rule-based systems, it uses machine learning to detect evolving manipulation patterns: keyword stuffing, unnatural link growth, cloaking, scaled content abuse, and site reputation abuse. The March 2026 Spam Update completed in under 20 hours — near real-time enforcement. AI agents unknowingly produce SpamBrain-triggering content because they optimize for keyword density and pattern-match to SEO templates. This tool catches those patterns before publishing.

**What is the difference between GEO and AEO?**
GEO (Generative Engine Optimization) focuses on being CITED by AI models that synthesize answers — ChatGPT, Perplexity, Google AI Overviews. The key tactics (from Princeton/Georgia Tech KDD 2024 research): add verifiable statistics every 150-200 words, cite authoritative sources, include expert quotes, structure content in modular autonomous sections. AEO (Answer Engine Optimization) focuses on being the DIRECT ANSWER that AI engines extract — answer-first format with 40-60 word atomic answers after each heading, entity consistency across the web, FAQPage schema markup. GEO gets you cited. AEO gets you quoted. Both are essential in 2026.

**Why is INP the critical Core Web Vital in 2026?**
INP (Interaction to Next Paint) replaced FID (First Input Delay) as Google's responsiveness metric. While FID only measured the delay of the FIRST interaction, INP measures ALL interactions throughout the entire session — every click, tap, and keyboard input. Target: <200ms. The most common cause of poor INP: long JavaScript tasks blocking the main thread. Fix: split long tasks, defer non-essential third-party scripts (chat, ads, analytics), avoid synchronous DOM updates. INP is now the metric most sites fail.

**When using `SEO Authority Prover`, how does it verify entity relationships within the JSON-LD schema?**
It validates proper knowledge graph linking using `@graph` and `@id`. This confirms that all entities—like your author, organization, and article—are correctly connected. Isolated data points confuse search engines; this tool builds strong connections.

**What specific semantic rules does `SEO Authority Prover` enforce when checking HTML structure?**
It verifies adherence to modern HTML5 standards, flagging the use of generic 'div soup.' The tool mandates using correct semantic tags like `<article>`, `<section>`, and `<footer>`. This improves accessibility and helps crawlers understand content hierarchy.

**If my canonical tag points to a different URL than my internal links, what does the `SEO Authority Prover` detect?**
It flags this as a critical signal conflict. The canonical tag must *always* point to the single, final indexable URL. If it conflicts with your actual link structure, Google ignores all signals and risks indexing the wrong version of your page.

**How does `SEO Authority Prover` relate technical validation to Core Web Vitals scores like LCP or INP?**
It doesn't fix performance itself, but it validates the necessary technical foundations. It catches errors—like lazy-loading the hero image (LCP issue) or excessive JavaScript tasks (INP issue)—that are causing your site to score poorly.