MCP server for technical SEO: connect your site data to AI

MCP stands for Model Context Protocol. It is the specification that lets AI coding assistants — Claude Code, Cursor, Claude Desktop — call external tools and retrieve data from external systems during a conversation. For technical SEO, this means an AI agent can query your actual crawl data, pull your real analytics numbers, and cross-reference your live search performance — instead of generating generic advice from training data. This guide covers how MCP servers work for SEO data, what tools Evergreen exposes, how to configure them across clients, and where the limits are.

For the broader context of AI-assisted website intelligence, the MCP + AI Website Intelligence pillar covers the category. For hands-on tutorials, the Claude Code SEO audit playbook and the agentic SEO workflows guide cover specific use cases.

Why MCP matters for technical SEO

The MCP SDK has hit 97 million monthly downloads as of March 2026, up from 2 million at the November 2024 launch. Over 13,000 public MCP servers exist. The protocol has crossed from experiment to infrastructure — and the SEO ecosystem is one of its strongest use cases.

Technical SEO auditing is fundamentally a data investigation. You crawl a site, collect signals (metadata, status codes, link structure, performance scores, search visibility), cross-reference those signals, and identify patterns that indicate problems or opportunities. This investigation pattern — retrieve data, analyze, decide what to look at next, retrieve more data — maps precisely to how AI agents with tool access work.

Before MCP, connecting AI tools to SEO data required custom integrations: building API wrappers, managing authentication, handling data formatting. MCP standardizes all of this. An AI client discovers available tools, understands their parameters, and calls them during conversation — the same way a developer calls functions in code.

The gap MCP fills for SEO specifically: existing MCP servers from third-party SEO platforms (DataForSEO, SE Ranking) expose their own proprietary data — keyword volumes, backlink profiles, SERP snapshots. What they don't expose is your site's own data: its crawl state, content health, internal linking structure, Lighthouse scores, and analytics. That's the data layer Evergreen's MCP server provides. For a detailed comparison of AI SEO approaches, see the automated SEO audits with AI guide.

How MCP servers work for SEO data

The protocol in one paragraph

MCP uses a client-server architecture over JSON-RPC. The MCP server (Evergreen, in this case) exposes "tools" — named functions with typed parameters and return values. The MCP client (Claude Code, Cursor, Claude Desktop) discovers these tools at connection time, presents them to the language model, and the model calls them during conversation when it needs data. The result comes back as structured data that the model can reason about and act on. No custom code, no API wrappers, no data formatting — just a configuration file that tells the client where to find the server.

Tools vs resources

MCP defines two main primitives: tools and resources. For SEO purposes, the distinction matters.

Tools are functions the AI calls with parameters. "Get all pages with missing meta descriptions" is a tool call. "Get Lighthouse scores below 50" is a tool call. Tools are active — they query, filter, and return specific data based on what the agent needs at that moment in the conversation.

Resources are static or semi-static data the AI can reference. A site's full page inventory, its crawl configuration, or its project metadata are resources. Resources provide context; tools provide answers to specific questions.

In practice, most SEO MCP interactions are tool calls. The agent asks a question ("which pages have the highest traffic but the worst Lighthouse scores?"), the model translates that into tool calls with appropriate filters, and the results come back as structured data that the model interprets.

The data flow

Here's what happens when you ask Claude Code "find pages on my site with missing meta descriptions":

1. Claude Code sees the Evergreen MCP tools in its available tool list
2. The model decides to call the get_pages tool with a filter for missing meta descriptions
3. The MCP client sends the tool call to the Evergreen MCP server
4. The server queries the crawl database and returns matching pages with their metadata
5. Claude Code receives the structured response and presents it — often with analysis, prioritization, or follow-up investigation

The key insight: the AI isn't scraping your site in real time. It's querying a persistent database of crawl data that Evergreen maintains. This means the data is comprehensive (every page, not just the homepage), historical (you can compare across crawls), and correlated (crawl data + analytics + search performance in the same query surface).

The MCP tools Evergreen exposes

Evergreen's MCP server exposes tools across five data domains:

Crawl data tools. Get pages by URL pattern, filter by status code, find pages with missing metadata (titles, descriptions, H1s, canonicals), identify redirect chains, discover orphan pages. These are the tools that power the content audit without spreadsheets workflow in an AI context.

Content audit tools. Get content quality signals — word count, readability, duplicate content detection, thin content identification. Filter and sort by any combination of attributes. Cross-reference with traffic data to prioritize.

Lighthouse performance tools. Get Lighthouse scores (performance, accessibility, best practices, SEO) for any page or filtered set of pages. Identify pages below threshold scores. Compare scores across crawls. The bulk Lighthouse testing guide covers what these scores mean.

Analytics tools. Get GA4 session data and GSC performance data (clicks, impressions, CTR, position) at the page level. The combine GA4 and Search Console data guide covers the manual version of this workflow — MCP makes it conversational.

Structure tools. Get site hierarchy, internal link counts, depth analysis, and navigation structure. These feed into the site architecture SEO best practices workflows.

Configuring MCP across clients

Claude Code

Claude Code discovers MCP servers from its configuration. Add the Evergreen server to your project's .mcp.json or global settings:

{
  "mcpServers": {
    "evergreen": {
      "command": "npx",
      "args": ["-y", "@evergreen-site/mcp-server"],
      "env": {
        "EVERGREEN_API_KEY": "evg_xxxxxxxxxxxx"
      }
    }
  }
}

Once configured, Claude Code automatically discovers the available tools. You can verify by asking "what Evergreen tools do you have access to?" and the model will list them.

Cursor

Cursor supports MCP servers through its settings. Add the same configuration in Cursor's MCP settings panel (Settings → MCP Servers → Add Server). The configuration format is identical to Claude Code's JSON format.

Claude Desktop

Claude Desktop reads MCP configuration from claude_desktop_config.json:

{
  "mcpServers": {
    "evergreen": {
      "command": "npx",
      "args": ["-y", "@evergreen-site/mcp-server"],
      "env": {
        "EVERGREEN_API_KEY": "evg_xxxxxxxxxxxx"
      }
    }
  }
}

On macOS, this file lives at ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows, %APPDATA%\Claude\claude_desktop_config.json.

After adding the configuration, restart the client. The Evergreen tools should appear in the tool list. If they don't, check that the API key is valid and that npx is available in your PATH.

Three workflows that demonstrate the value

Workflow 1: The quick technical audit

You say: "Run a quick technical audit of my site. Focus on the issues that affect the most pages."

The agent does: Queries crawl data for site-wide issue counts (missing titles, missing descriptions, broken links, redirect chains, missing canonicals). Sorts by page count. Presents the top five issues with affected page counts and sample URLs. Follows up by checking which affected pages have the highest organic traffic — because a missing meta description on your highest-traffic page matters more than one on a page nobody visits.

This workflow replaces the first 30 minutes of a traditional website audit checklist — the data collection and initial triage. The strategic interpretation is still yours.

Workflow 2: The content decay detector

You say: "Which pages have lost the most organic traffic in the last three months? For each one, check if there are also technical issues."

The agent does: Queries GSC data for traffic decline, correlates with crawl data for technical issues (status code changes, metadata changes, rendering issues), and presents findings as a combined view. This is the content decay analysis workflow — automated.

Workflow 3: The pre-launch audit

You say: "I'm about to launch a redesigned version of this site. Compare the current crawl with the staging crawl and flag anything that might break SEO."

The agent does: Compares page inventories (missing pages = potential 404s), metadata differences (changed titles = potential ranking fluctuation), internal link count changes (reduced links = reduced authority distribution), and structural changes (new orphan pages, changed depth levels). This workflow maps directly to the migration validation process in the WordPress to headless CMS playbook.

The moat: persistent data vs ad-hoc scripts

You can vibe-code a crawler. You can't vibe-code institutional memory.

This distinction is the core argument for MCP-connected website intelligence over ad-hoc AI scripts. A developer can ask Claude Code to "crawl my site and find SEO issues" without any MCP server. Claude Code will write a script, run it, and produce a snapshot. That snapshot is useful — once. It has no history, no analytics correlation, no comparison baseline, and no persistence. Tomorrow, the script's output is stale.

Evergreen's MCP server exposes data from a continuously-maintained crawl database. The crawler runs on a schedule (daily for Pro accounts). Analytics data updates automatically via OAuth integrations. Lighthouse scores accumulate over time. When an AI agent queries this data, it's querying institutional memory — the accumulated understanding of how your site has changed, what's improved, what's degraded, and how search engines are responding.

Ad-hoc scripts are good for one-time investigations. Persistent data is good for ongoing intelligence. The difference between a one-time audit and continuous site monitoring is the difference between a snapshot and a movie — and the movie is where the actionable insights live.

Putting it together in Evergreen

The complete workflow from zero to MCP-powered SEO auditing:

1. Create an Evergreen account (free tier: 1 project, 500 pages). Add your site and run the initial crawl. The crawler discovers pages, extracts metadata, checks status codes, maps internal links, and builds the content audit table.

2. Connect GA4 and GSC (optional, Pro tier). OAuth-based connections that import traffic and search performance data at the page level. Once connected, analytics data is available through MCP tools alongside crawl data.

3. Configure your MCP client. Add the Evergreen MCP server configuration to Claude Code, Cursor, or Claude Desktop using the JSON configuration shown above. Restart the client.

4. Start asking questions. The tools are discovered automatically. Ask about missing metadata, broken links, performance issues, traffic trends, or structural problems. The AI agent calls the appropriate tools, retrieves your data, and presents findings with analysis.

5. Iterate and investigate. The power of agentic workflows is the follow-up. "Show me pages with missing meta descriptions" → "Which of those have the most traffic?" → "Draft meta descriptions for the top five" → "Now check if any of those pages also have Lighthouse issues." Each step builds on the previous one, using real data from your site.

The entire setup takes about five minutes. The first useful audit finding usually appears within the first conversation turn.

FAQ

Do I need a paid Evergreen account for MCP access?

MCP server access is included in the Pro plan ($49/mo). The free tier lets you crawl and audit a site but doesn't include MCP access. You can evaluate the audit data through the web interface on the free tier, then upgrade to Pro when you're ready to connect AI tools.

Which AI clients support MCP?

Claude Code, Cursor, and Claude Desktop all support MCP natively. Any client that implements the MCP specification can connect to Evergreen's server. The ecosystem is growing — new clients are adding MCP support regularly.

Can I use MCP with other SEO tools alongside Evergreen?

Yes. MCP clients can connect to multiple servers simultaneously. You could have Evergreen's MCP server for your site's crawl data and another server (DataForSEO, for example) for keyword research data. The AI agent can query both servers in the same conversation and cross-reference the results.

How fresh is the data exposed through MCP?

Crawl data reflects the most recent completed crawl. On the Pro tier with daily sync, data is at most 24 hours old. Analytics data (GA4, GSC) updates based on the source API's latency — typically 24–48 hours. Lighthouse scores are captured during each crawl cycle.

Does Evergreen's MCP server work with models other than Claude?

The MCP server exposes a standard protocol. Any AI model that can call MCP tools can use it. In practice, Claude (via Claude Code and Claude Desktop) and models accessed through Cursor are the primary clients today.

What to do next

MCP-connected SEO auditing is functional today — not theoretical, not aspirational, not "coming soon." The tools exist, the data layer exists, and the workflows produce genuine insights that would take hours to derive manually.

Three things are true simultaneously: AI-powered auditing produces real value for data retrieval and pattern recognition. It does not replace strategic SEO judgment. And the quality of the output depends entirely on the quality of the data the AI has access to — which is why the persistent data layer matters more than the model.

Put your site data in your AI workflow. Start free →

Related resources

• MCP + AI-Assisted Website Intelligence — the parent pillar for MCP and website data
• Claude Code SEO audit: the developer's playbook — hands-on Claude Code tutorial
• Agentic SEO workflows — the conceptual framework for AI-driven auditing
• Automated SEO audits with AI — the landscape of AI audit tools
• Technical SEO audit: the complete guide — the traditional audit methodology
• Website audit checklist for agencies — agency audit workflows
• Content audit without spreadsheets — the visual audit approach
• Headless CMS SEO — headless CMS context for MCP workflows