seo-analytics-mcp
An MCP server that lets Claude query your own site's search and analytics data — Google Search Console, GA4 and IndexNow — in natural language.
See your properties — list every Search Console property (and GA4 account/property) the authorised Google account can read, with permission levels.
Query Search Console performance — clicks, impressions, CTR and position broken down by query, page, country, device or date, with filters and search types (web, image, video, news, discover).
Find what changed — diff two consecutive periods and get the biggest movers up and down for any metric and dimension.
Check indexing — inspect a single URL's coverage verdict, canonical, last crawl and rich results, and list submitted sitemaps with their warnings and errors.
Run GA4 reports — arbitrary dimensions/metrics/filters/ordering, plus a preset landing-page report that joins to Search Console via a normalised
pathkey.Get a whole-page picture — one call returning a URL's GSC trend, top queries, GA4 engagement and index status together.
Submit to IndexNow — verify your key file, then batch-submit URLs to Bing, Yandex and others (dry run first, then token-gated confirm).
Write carefully — sitemap submission and IndexNow submission both require explicit confirmation (plus write scope or a bound submission token) and are flagged destructive.
Diagnose auth — report the active profile, held scopes, which APIs actually answer, and the exact command to run next.
Trust the numbers — every read returns a consistent
summary/rows/notes/exportshape, with totals over all fetched rows and caveats (anonymised queries, sampled data, truncation) travelling with the data.
Provides tools for Google Search Console, enabling search analytics queries, period comparisons, URL index inspection, and sitemap submission and verification.
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-analytics-mcp Which pages lost the most clicks in the last 28 days versus the 28 before?"
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.
Google Search Console, GA4 and IndexNow — as an MCP server.
Ask Claude about your own sites. What's ranking, what changed, what's indexed, what's converting.
"Which pages lost the most clicks in the last 28 days versus the 28 before?"
"How is /pricing doing?"
"Is https://example.com/new-post indexed yet?"
"Which pages rank on page one but get almost no clicks?"
"Top 20 queries for the blog last month, and which of them convert in GA4."You authorise your own Google account against an OAuth client in your own Google Cloud project. Nothing about your access flows through anyone else, this repository contains no credentials, and every Google quota you spend is your own.
Contents
Install · Setup · The seven-day problem · Tools · Response shape · Configuration · Writes · Profiles · Design · Troubleshooting · Development
Related MCP server: GSC Analyst Connector
Install
Requires Python 3.10+ and uv.
uvx seo-analytics-mcp doctor # no install needed — prints your setup steps, in orderdoctor is the whole onboarding experience. It tells you exactly what is missing and what to
run next, at every stage. If you read nothing else here, run that.
Setup
Six clicks in the Google Cloud console, then one command. Ten minutes, once.
Create a Google Cloud project — or reuse one. console.cloud.google.com/projectcreate
Enable the APIs. Search Console is required; the GA4 pair is optional.
searchconsole ·
analyticsdata ·
analyticsadmin
Configure the consent screen, then press Publish app. console.cloud.google.com/auth/overview
Choose External and publish. You are the only user of your own app, so Google's personal-use exception applies and no verification is needed. Workspace users can choose Internal instead.
Do not skip the Publish step — see below.
Create an OAuth client of type Desktop app and download the JSON.
console.cloud.google.com/auth/clients
A Web application client cannot do the loopback redirect this server needs. doctor checks
for this specific mistake, because it is the easy one to make.
Authorise, once, from a terminal:
uvx seo-analytics-mcp auth --client-secret ~/Downloads/client_secret_*.jsonYour browser opens. Google says "Google hasn't verified this app" — expected for your own
client: Advanced → Continue. The token lands in your profile directory at mode 0600.
Check, then connect:
uvx seo-analytics-mcp doctor # eleven checks; exit 0 means it will workConnect it
claude mcp add seo \
-e GSC_DEFAULT_SITE=sc-domain:example.com \
-e GA4_DEFAULT_PROPERTY=properties/123456789 \
-- uvx seo-analytics-mcp{
"mcpServers": {
"seo": {
"command": "uvx",
"args": ["seo-analytics-mcp"],
"env": {
"GSC_DEFAULT_SITE": "sc-domain:example.com",
"GA4_DEFAULT_PROPERTY": "properties/123456789"
}
}
}
}Then quit Claude Desktop completely (⌘Q — closing the window is not enough) and reopen.
There isno credential path in that config. The token lives in the profile directory that
seo-mcp auth wrote, so the whole block is safe to paste into a GitHub issue.
The seven-day problem
If the server works and then stops about a week later, this is why.
Google issues refresh tokens that expire after seven days for any external OAuth app whose publishing status is still Testing. The obvious setup path — create project, create client, add yourself as a test user — leaves you there.
The fix is one click: on the consent screen, set the audience to External and press
Publish app. Then uvx seo-analytics-mcp auth --reauth.
doctor flags a token young enough to still be a Testing token, and every invalid_grant error
from the server explains this in full. It is not a bug in the server — but it will be the most
common issue filed against it.
Tools
Twenty-five tools: twenty-two map to upstream operations, two join sources, and one exists purely so the model can tell a confused user what to do.
Tool | What it does | |
🔎 |
| Properties this account can read, with permission level |
🔎 |
| Clicks, impressions, CTR, position by any dimension combination |
🔎 |
| Two windows diffed — biggest movers, both directions |
🔎 |
| Index status, coverage, canonical, last crawl, rich results |
🔎 |
| Submitted sitemaps with warnings and error counts |
✍️ |
| Submits a sitemap — write scope and explicit confirm |
📊 |
| Accounts and properties, to resolve a numeric property ID |
📊 |
| Arbitrary |
📊 |
| Sessions, engagement, conversions by landing page |
⚡ |
| Checks the key file is published correctly |
⚡ |
| Batch submit — dry run by default, token-gated confirm |
📧 |
| Lists on the account, member counts, lifetime rates |
📧 |
| Sent campaigns newest first, with delivery and engagement |
📧 |
| One campaign in full, plus the links its recipients clicked |
📧 |
| Which links were clicked, most-clicked first |
💼 |
| Pages this token administers, with follower totals |
💼 |
| Post impressions, clicks, reactions and engagement rate |
💼 |
| Followers gained, split into organic and paid |
💼 |
| Views of the Page itself, by section |
📺 |
| Subscribers, lifetime views, video count |
📺 |
| Recent uploads with public views, likes and comments |
📺 |
| Watch time, view duration and subscriber movement |
📺 |
| Where views came from — search, suggested, external |
🔗 |
| One URL: GSC trend, top queries, GA4 engagement, index status |
🩺 |
| Active profile, scopes, which APIs answer, what to run next |
What a response looks like
Every read tool returns the same four keys. Bounded, self-describing, and carrying its own caveats.
{
"summary": {
"source": "gsc",
"rows_returned": 10, // what you see
"rows_matched": 1847, // what exists upstream
"date_range": "2026-07-29..2026-08-25", // resolved, always echoed
"data_state": "final",
"totals": { "clicks": 4730, "impressions": 512903, "ctr": 0.0092, "position": 12.4 }
},
"rows": [ /* capped at min(row_limit, 1000) */ ],
"notes": [
"Google anonymises rare queries: these rows do NOT sum to property totals.",
"dataState=final excludes the most recent 2-3 days.",
"1837 further rows were not included inline."
],
"export": "~/.../exports/a1b2c3.csv" // only when rows spilled
}Three conventions hold everywhere:
Totals cover every row fetched, not just the rows shown — a model that sees ten rows and a
total for ten cannot tell truncation from reality. Rates are never averaged: ctr is recomputed
from clicks ÷ impressions, position is impression-weighted, engagementRate is
engaged ÷ sessions.
Caveats travel with the data. Whichever layer knows the caveat appends it: the client knows
the query dimension was requested, shape() knows how many rows it dropped, GA4 knows the
response was sampled. Docstrings alone lose them exactly when the model is looking at the numbers.
Errors name the fix. A 403 tells you which grant to check and where — never a raw Google error body.
The authorised Google account has no access to sc-domain:example.com. Confirm the
account you authorised is the one with access — Search Console grants are per-property
under Settings > Users and permissions, GA4 grants are per-property under Admin >
Property access management. If access was added recently, run `seo-mcp auth --reauth`.Configuration
Every variable is optional. Precedence: tool argument → environment → profile config.json.
Variable | Purpose |
| Default property, e.g. |
| Default GA4 property, e.g. |
| Which profile to use (default: |
| Override the profile root directory |
| Required only for IndexNow |
| Required only for the Mailchimp tools. The suffix ( |
| Required only for the LinkedIn tools. A member token, not an app key — see below |
| Default Page, e.g. |
|
|
| Public YouTube counts and the video list |
| Default channel, e.g. |
| Owner analytics — watch time, retention, traffic sources. From |
|
|
Hosted deployment only:
Variable | Purpose |
| The endpoint path. Make it long and random |
| Public hostname(s). Without it, every proxied request fails with |
| Where access tokens live (default: profile root). Must be on a writable path — under |
| Fallback only: |
YouTube needs two credentials, and Google insists on it
The Data API answers public questions — subscribers, views, a video's likes — from a plain API key. The Analytics API answers the questions worth asking — watch time, average view duration, where the views came from — and cannot use a service account at all: Google's own documentation states a service account cannot be linked to a YouTube channel, so requests authorised that way simply error.
So YouTube carries its own OAuth credential, separate from whatever else the server is
authenticated as, because credentials.mode() is a single switch and a service account
would otherwise claim YouTube too.
seo-analytics-mcp youtube-auth # sign in as the channel OWNER; prints three valuesPaste those into the server's environment. Publish the OAuth app before relying on it — while it is in Testing, Google expires refresh tokens after 7 days, which is the same seven-day problem described above.
Either half works without the other. auth_status reports them separately, so a
half-configured install says which half.
LinkedIn is not like the others
Mailchimp and the Google APIs authenticate a machine. LinkedIn does not: statistics come back only for Pages the signing member administers, so the credential is one person's token and it expires after about 60 days with no unattended renewal. This project already abandoned a personal OAuth token once for exactly that reason, so the tools say so up front rather than leaving a dead deployment looking broken.
To set it up: create an app at developer.linkedin.com, request the Community
Management API product, give the signing member an ADMINISTRATOR role on the
Page, and authorise with r_organization_social and rw_organization_admin. A token
missing either the product or the role authenticates perfectly and reads nothing —
auth_status reports which Pages it can actually see, so that case is visible rather
than silent.
Google sign-in (optional front door)
With it on, somebody adds the connector in their AI tool, clicks through a Google sign-in, and is done — no key to paste, nothing for an administrator to hand out. The server becomes an OAuth 2.1 authorization server that never sees a password: the login itself is Google's, and all this does is decide whether the person Google vouched for is allowed in.
Variable | Purpose |
| This server's public address, e.g. |
| A Google OAuth Web application client |
| Who may sign in, e.g. |
| Individuals outside those domains |
The redirect URI to register with Google is <SEO_MCP_PUBLIC_URL>/auth/google/callback.
seo-analytics-mcp people # who has signed in, and when
seo-analytics-mcp people --revoke someone@example.comThree things worth knowing:
It fails closed. Configured without a domain or email policy, sign-in stays off rather than admitting every Google account in existence. Same for a missing
SEO_MCP_PUBLIC_URL. The server logs why and runs on static tokens.Static tokens keep working. They are verified through the same path, so this can be switched on without disconnecting anyone mid-conversation.
Domain membership is checked on the
hdclaim, not on the text after the@, so a personal account cannot get in by looking like a company one.
Access tokens
The hosted server refuses to start unless at least one token exists — serving openly is never the fallback. Issue one per person:
seo-analytics-mcp token mint alice # prints the token once; only its hash is stored
seo-analytics-mcp token mint dev --days 30 # optional expiry
seo-analytics-mcp token list # who has access, and when they last used it
seo-analytics-mcp token revoke alice # effective on the next request, no restartClients send it in an x-api-key header, as a bare token. Several equivalent
names are accepted (x-auth-token, x-apikey, api-key, apikey,
x-api-token, x-authorization, authorization), and a Bearer prefix is
optional throughout.
x-api-key is documented because that is what client UIs permit: claude.ai
allowlists header names on custom connectors, refuses to save an unapproved one,
and reserves Authorization for its own OAuth token. authorization is checked
last so a proxy's own token cannot shadow a deliberately configured key.
Only the SHA-256 of each token is stored, so the database can be copied off the host
and still grants nobody access. Revocation is immediate because the gate queries per
request rather than holding a snapshot, and a revoked token cannot be resurrected by
the same string lingering in SEO_MCP_TOKENS.
The CLI reads
.envfrom the working directory, but a hardened deployment keeps that file root-owned and0600. When runningtokencommands as the service account, pass the path explicitly — otherwise the token lands in a database the server never reads:sudo -u seomcp SEO_MCP_TOKEN_DB=/opt/seo-analytics-mcp/state/tokens.db \ /opt/seo-analytics-mcp/.venv/bin/seo-analytics-mcp token mint aliceEvery command prints the database it used, so a mismatch is visible immediately.
Dates
Every date argument accepts YYYY-MM-DD, today, yesterday or NdaysAgo. Responses echo the
absolute range they actually used, because a model that guesses today's date wrong produces an
empty result that reads as "traffic went to zero".
Search Console lags 2–3 days and retains ~16 months; ranges outside those bounds are flagged or refused rather than silently returning nothing. GA4 reports in the property's own timezone, so its dates do not line up exactly with Search Console's — the responses say so where it matters.
Writes
Two tools act on the world outside your machine. Both are deliberately awkward.
| Needs the write scope (not granted by default) and |
| Verifies your key file, then returns a |
Aconfirm flag alone is not a safety mechanism — it is an argument the model fills in,
and the same misreading that produces the wrong URLs produces confirm=true beside them.
The token is unforgeable without a dry run, and change one URL and it stops matching. Both
tools also carry destructiveHint annotations, so a client that gates destructive tools behind
its own approval prompt will do so.
Read-only scopes are the default. A stranger installing an SEO tool that immediately asks for permission to modify their Search Console properties will reasonably decline.
Profiles
Several Google accounts on one machine — for agencies holding client properties side by side.
uvx seo-analytics-mcp auth --profile client-a --client-secret ./client-a.json
uvx seo-analytics-mcp auth --profile client-b --client-secret ./client-b.json
uvx seo-analytics-mcp profiles listSet SEO_MCP_PROFILE per MCP server entry. Cache keys include the profile, so two accounts
can never serve each other's data.
A profile is one directory — the first thing you will ever ask a user to delete:
uvx seo-analytics-mcp profiles rm client-a --yesThey live in ~/Library/Application Support/seo-mcp/ (macOS), $XDG_CONFIG_HOME/seo-mcp/
(Linux) or %APPDATA%\seo-mcp\ (Windows).
Design
Four layers, strictly downhill. Get this wrong and the auth flow ends up inside a tool call, which is the failure the whole design exists to prevent.
flowchart TD
subgraph L4["Entry points"]
S[server.py<br/><i>MCPServer, stdio</i>]
C[cli.py<br/><i>auth · doctor · profiles · serve</i>]
end
subgraph L3["Tools — argument surface, docstrings, cache policy"]
T[13 handlers<br/><i>no HTTP, no credentials, no row shaping</i>]
end
subgraph L2["Clients — the only modules that speak HTTP"]
G[gsc.py]
A[ga4.py]
I[indexnow.py]
end
subgraph L1["Leaves — importable by anyone, import nobody"]
LV[shaping · errors · config · cache · auth/store · auth/scopes]
end
F[auth/flow.py<br/><i>loopback + PKCE · opens a browser</i>]
S --> T
C --> T
C -.->|only reachable from here| F
T --> G & A & I
G & A & I --> LVThe browser flow must never run inside a tool call. An MCP tool that blocks on stdio waiting for a human to finish a consent screen looks like a hung server, and the model has no way to help. One CLI command, run once, is the whole difference — and a test walks the AST of every module to enforce it.
Other rules the tests enforce mechanically: shaping.py imports no Google library (which is why
the row logic is fully unit-testable with no credentials), tools import no HTTP library, and
nothing on the server path calls print() — on a stdio transport, stdout carries JSON-RPC and a
single stray print corrupts the stream.
Troubleshooting
Symptom | Cause |
Worked, then stopped after a week | OAuth app still in Testing — see above |
| Create a Desktop app OAuth client instead |
| Wrong Google account, or no grant on that property |
| Enable it on the project that issued your OAuth client, then wait a minute |
GA4 returns a 400 | An incompatible dimension/metric pair — not every GA4 dimension works with every metric |
Server never appears in the client | Run |
Every issue report should include seo-mcp doctor --json. It contains no credentials — only
paths, versions, which checks passed and which APIs answered.
Development
uv sync --extra dev
uv run pytest -q # 147 tests · no credentials · no network
uv run python scripts/smoke.py # drives the server over real stdio JSON-RPC
uv run ruff check src testspython3 -m venv .venv && ./.venv/bin/pip install -e ".[dev]"
./.venv/bin/python -m pytest -q
./.venv/bin/python scripts/smoke.py ./.venv/bin/seo-mcpscripts/smoke.py starts the server as a subprocess, completes the MCP handshake, lists the
tools and calls several — using a throwaway profile directory, so your real token is untouched.
It is the fastest way to confirm the protocol side works before any Google credential exists.
To poke at it by hand, the MCP Inspector needs nothing beyond Node:
npx @modelcontextprotocol/inspector ./.venv/bin/seo-mcp # web UI
npx @modelcontextprotocol/inspector --cli ./.venv/bin/seo-mcp \
--method tools/call --tool-name auth_status # scriptableNot covered by automated tests: the OAuth flow itself and live IndexNow submission. Both need a human and a real domain, and mocking them would only test the mock. They belong in a short manual release checklist.
Two things it will not do
IndexNow does not reach Google. Participants are Bing, Yandex, Naver, Seznam.cz, Yep and
Amazon — one endpoint propagates to all of them. Google does not participate, and Google's own
Indexing API only accepts pages carrying JobPosting or BroadcastEvent structured data. If
you install this expecting faster Google indexing, you will be disappointed.
Query rows never sum to totals. Google anonymises rare queries, so any breakdown by the
query dimension undercounts. Every response carrying that dimension repeats the caveat,
because a model handed those rows will otherwise compute confidently wrong percentages.
Contributing
Issues and pull requests welcome. The credential-free test suite runs on every push across Linux, macOS and Windows on Python 3.10 and 3.13 — if it passes locally it will pass in CI.
Renaming a tool or changing an argument breaks every saved prompt a user has. Those changes go in CHANGELOG.md and are a minor bump before 1.0, a major one after.
Licence
MIT.
Available Tools
13 toolsauth_statusARead-only
Report which profile is active, which scopes its token holds, and which Google APIs actually answer. Call this first whenever another tool returns a permission error: the response names the exact command the user should run in their terminal.
Inputs: no named parameters. Returns: object
ga4_landing_pagesARead-only
Sessions, engagement rate, conversions and revenue by landing page - the preset that joins to Search Console. Every row gains a normalised 'path' key ('/pricing', no host, no trailing slash, no query string) which is directly comparable to the 'path' key added by gsc_search_analytics rows grouped by page.
Inputs: top_n, end_date, start_date, property_id, +1 more. Returns: What every read tool returns. Four keys, always the same shape.
ga4_list_propertiesARead-only
List the GA4 accounts and properties this Google account can read, so a property name can be resolved to the numeric ID every other GA4 tool needs. Universal Analytics properties are not returned - they no longer exist in this API.
Inputs: no named parameters. Returns: What every read tool returns. Four keys, always the same shape.
ga4_run_reportARead-only
Run an arbitrary GA4 report (the runReport method).
metrics and dimensions are GA4 API names, not UI labels: 'sessions', 'activeUsers', 'screenPageViews', 'conversions', 'totalRevenue'; 'landingPage', 'pagePath', 'sessionDefaultChannelGroup', 'country', 'date'. Not every dimension is compatible with every metric - a 400 error means the pair is not queryable together, not that the names are wrong. dimension_filter and order_by take GA4 FilterExpression and OrderBy objects as plain dicts. Dates accept YYYY-MM-DD, 'today', 'yesterday' or 'NdaysAgo'. GA4 reports in the property's own timezone, so its dates do not line up exactly with Search Console's.
Inputs: metrics (required), limit, end_date, order_by, +4 more. Returns: What every read tool returns. Four keys, always the same shape.
gsc_compare_periodsARead-only
Compare two consecutive Search Console periods and return the biggest movers in both directions - the 'what changed' question in one call.
period_days is the length of each window; the current window ends offset_days before the freshest available data, and the comparison window is the period_days immediately before it. metric is clicks, impressions, ctr or position. For position, a DECREASE is an improvement, and the response says so. dimension is usually page or query; query rows are anonymised by Google and will not sum to totals.
Inputs: top_n, metric, site_url, dimension, +2 more. Returns: object
gsc_inspect_urlARead-only
Inspect one URL's index status in Google: coverage verdict, last crawl time, Google's chosen canonical versus the declared one, robots.txt state, mobile usability and rich-result verdicts. inspection_url must be a full URL that belongs to site_url. This is the tightest Google quota in the set (2,000 calls per day per property), so results are cached for an hour.
Inputs: inspection_url (required), site_url. Returns: object
gsc_list_sitemapsARead-only
List the sitemaps submitted for a property, with when each was last downloaded by Google and how many warnings and errors it carries. A sitemap Google has never downloaded, or one with errors, is usually the answer to 'why isn't this indexed'.
Inputs: site_url. Returns: What every read tool returns. Four keys, always the same shape.
gsc_list_sitesARead-only
List the Search Console properties this Google account can read, with the permission level held on each. Call this first in any session: the exact string returned here is what every other Search Console tool needs as site_url. Domain properties look like 'sc-domain:example.com'; URL-prefix properties are full URLs with a trailing slash.
Inputs: no named parameters. Returns: What every read tool returns. Four keys, always the same shape.
gsc_search_analyticsARead-only
Query Search Console performance data: clicks, impressions, CTR, position.
Dates are YYYY-MM-DD, or 'today' / 'yesterday' / 'NdaysAgo'; the absolute range actually used is echoed in summary.date_range. dimensions may include query, page, country, device, date (default ["query"]). filters are "dimension operator value", e.g. "page contains /blog/". search_type is web, image, video, news or discover. data_state "final" excludes the most recent 2-3 incomplete days; "all" is fresher but unstable. Rows carrying the 'query' dimension are anonymised by Google and will NOT sum to property totals - never compute shares or percentages from them.
Inputs: filters, end_date, site_url, row_limit, +4 more. Returns: What every read tool returns. Four keys, always the same shape.
gsc_submit_sitemapADestructive
Submit or re-ping a sitemap to Search Console. THIS WRITES TO THE USER'S LIVE PROPERTY. It needs the write scope, which is not granted by default, and it is a dry run unless confirm=true. Show the dry run to the user and get their explicit agreement before calling it again with confirm=true. feedpath must be the full sitemap URL, e.g. https://example.com/sitemap.xml.
Inputs: feedpath (required), confirm, site_url. Returns: object
indexnow_submitADestructive
Submit URLs to IndexNow so participating search engines recrawl them. THIS ACTS ON THE LIVE WEB and cannot be undone.
Called without confirm it is a DRY RUN: it validates the key file and the URL list and returns a submission_token. Show that dry run to the user, then call again with confirm=true AND the exact submission_token you were given. The token is bound to that precise URL list, so if the list changes you must dry-run again.
IndexNow notifies Bing, Yandex, Naver, Seznam.cz, Yep and Amazon. Google does NOT participate - this will not speed up Google indexing. Per-endpoint HTTP status is returned verbatim, because 200, 202, 400, 403, 422 and 429 all mean different things.
Inputs: urls (required), host, confirm, endpoint, +1 more. Returns: object
indexnow_verify_keyARead-only
Check that this host's IndexNow key file is correctly published: reachable, HTTP 200, served as text, and containing exactly the configured key. Every submission runs this check itself and aborts if it fails, so use this tool to diagnose a rejected submission. The key is read from configuration, never passed in.
Inputs: host, key_location. Returns: object
page_reportARead-only
Everything known about one page in a single call: its Search Console clicks and impressions trend, its top queries, its GA4 engagement, and its current index status. Use this for 'how is /pricing doing?'.
GA4 and index status are included on a best-effort basis - if GA4 is not authorised or the property is unknown, the Search Console half is still returned, with a note saying what was left out.
Inputs: url (required), days, site_url, property_id. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
Most tools target a distinct API and resource, but a few reporting tools overlap: page_report and gsc_inspect_url both report index status, and gsc_search_analytics/gsc_compare_periods both query performance. Descriptions are detailed enough to usually disambiguate, but an agent could still misselect on a quick read.
The dominant pattern is prefix_verb_noun (gsc_list_sites, ga4_run_report, indexnow_verify_key), but some tools deviate: page_report, auth_status, ga4_landing_pages, and indexnow_submit. The naming is consistent enough to be predictable, though not fully uniform.
13 tools is well within the sweet spot for a multi-API SEO server. Each tool covers a distinct operation or preset, and none feels redundant or gratuitous given the GSC, GA4, and IndexNow surface.
The surface covers GSC property discovery, performance queries, URL inspection, sitemap submission, GA4 reporting, and IndexNow submission. Minor gaps exist—notably no sitemap deletion and no GA4 metadata discovery—but core SEO workflows are fully usable.
Maintenance
Related MCP Connectors
Query your SEO data in plain language: rankings, audits, backlinks, competitors and AI visibility.
Query your Google Search Console, GA4 and Bing Webmaster data across every site you run.
Turn Search Console data into SEO actions, content, publishing, indexing, and AI insights.
SEO data your AI can cite: Search Console, GA4, keywords, backlinks, SERPs and AI visibility.
Related MCP Servers
- FlicenseAqualityDmaintenanceIntegrates with Google Search Console to enable querying search analytics, comparing performance periods, generating visual reports, and identifying SEO optimization opportunities through natural language.59-
- FlicenseNot gradedqualityDmaintenanceEnables querying Google Search Console data via natural language, providing tools for site traffic analysis, page changes, and optimization opportunities.-
- AlicenseNot gradedqualityDmaintenanceEnables querying Google Search Console and Google Analytics 4 through natural language, with tools for SEO analysis like anomaly detection, cannibalization detection, and opportunity scoring.1MIT
- AlicenseNot gradedqualityDmaintenanceEnables querying Google Search Console data, including search analytics with advanced filtering, quick wins detection, and rich dimensions, through natural language.9,552 npmMIT