Skip to main content
Glama
seo-analytics-mcp

seo-analytics-mcp

by zainsive

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.

PyPI Python License: MIT MCP Tests


"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 order

doctor 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_*.json

Your 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 work

Connect 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.

NOTE

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

WARNING

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

🔎

gsc_list_sites

Properties this account can read, with permission level

🔎

gsc_search_analytics

Clicks, impressions, CTR, position by any dimension combination

🔎

gsc_compare_periods

Two windows diffed — biggest movers, both directions

🔎

gsc_inspect_url

Index status, coverage, canonical, last crawl, rich results

🔎

gsc_list_sitemaps

Submitted sitemaps with warnings and error counts

✍️

gsc_submit_sitemap

Submits a sitemap — write scope and explicit confirm

📊

ga4_list_properties

Accounts and properties, to resolve a numeric property ID

📊

ga4_run_report

Arbitrary runReport — dimensions, metrics, filters, ordering

📊

ga4_landing_pages

Sessions, engagement, conversions by landing page

⚡

indexnow_verify_key

Checks the key file is published correctly

⚡

indexnow_submit

Batch submit — dry run by default, token-gated confirm

📧

mailchimp_list_audiences

Lists on the account, member counts, lifetime rates

📧

mailchimp_list_campaigns

Sent campaigns newest first, with delivery and engagement

📧

mailchimp_campaign_report

One campaign in full, plus the links its recipients clicked

📧

mailchimp_campaign_links

Which links were clicked, most-clicked first

💼

linkedin_list_organizations

Pages this token administers, with follower totals

💼

linkedin_share_stats

Post impressions, clicks, reactions and engagement rate

💼

linkedin_follower_stats

Followers gained, split into organic and paid

💼

linkedin_page_stats

Views of the Page itself, by section

📺

youtube_channel_stats

Subscribers, lifetime views, video count

📺

youtube_recent_videos

Recent uploads with public views, likes and comments

📺

youtube_channel_report

Watch time, view duration and subscriber movement

📺

youtube_traffic_sources

Where views came from — search, suggested, external

🔗

page_report

One URL: GSC trend, top queries, GA4 engagement, index status

🩺

auth_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

GSC_DEFAULT_SITE

Default property, e.g. sc-domain:example.com — so prompts never name it

GA4_DEFAULT_PROPERTY

Default GA4 property, e.g. properties/123456789

SEO_MCP_PROFILE

Which profile to use (default: default)

SEO_MCP_HOME

Override the profile root directory

INDEXNOW_HOST · INDEXNOW_KEY

Required only for IndexNow

MAILCHIMP_API_KEY

Required only for the Mailchimp tools. The suffix (-us15) selects the data centre

LINKEDIN_ACCESS_TOKEN

Required only for the LinkedIn tools. A member token, not an app key — see below

LINKEDIN_ORGANIZATION_ID

Default Page, e.g. 1234567 — so prompts never name it

LINKEDIN_API_VERSION

YYYYMM. LinkedIn retires versions on a rolling basis; override when it does

YOUTUBE_API_KEY

Public YouTube counts and the video list

YOUTUBE_CHANNEL_ID

Default channel, e.g. UCVsEgKMBL1DREac01aQf5zA

YOUTUBE_REFRESH_TOKEN · YOUTUBE_OAUTH_CLIENT_ID · YOUTUBE_OAUTH_CLIENT_SECRET

Owner analytics — watch time, retention, traffic sources. From youtube-auth

SEO_MCP_LOG_LEVEL

DEBUG for verbose logging — always on stderr, never stdout

Hosted deployment only:

Variable

Purpose

SEO_MCP_ENDPOINT_PATH

The endpoint path. Make it long and random

SEO_MCP_ALLOWED_HOSTS

Public hostname(s). Without it, every proxied request fails with 421 Invalid Host header

SEO_MCP_TOKEN_DB

Where access tokens live (default: profile root). Must be on a writable path — under systemd with ProtectSystem=strict, that means a ReadWritePaths= directory

SEO_MCP_TOKENS

Fallback only: label:token pairs in plaintext. Prefer token mint

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 values

Paste 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

SEO_MCP_PUBLIC_URL

This server's public address, e.g. https://mcp.example.com

GOOGLE_SSO_CLIENT_ID · GOOGLE_SSO_CLIENT_SECRET

A Google OAuth Web application client

GOOGLE_SSO_ALLOWED_DOMAINS

Who may sign in, e.g. example.com

GOOGLE_SSO_ALLOWED_EMAILS

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.com

Three 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 hd claim, 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 restart

Clients 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 .env from the working directory, but a hardened deployment keeps that file root-owned and 0600. When running token commands 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 alice

Every 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.

gsc_submit_sitemap

Needs the write scope (not granted by default) and confirm=true. Without confirm it is a dry run.

indexnow_submit

Verifies your key file, then returns a submission_token bound by hash to that exact URL list. Submitting needs confirm=true and that token.

IMPORTANT

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 list

Set 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 --yes

They 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 --> LV

The 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

client type: FAIL … this is a Web client

Create a Desktop app OAuth client instead

no access to sc-domain:…

Wrong Google account, or no grant on that property

…API is not enabled

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 doctor first, then check your client's MCP log

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 tests
python3 -m venv .venv && ./.venv/bin/pip install -e ".[dev]"
./.venv/bin/python -m pytest -q
./.venv/bin/python scripts/smoke.py ./.venv/bin/seo-mcp

scripts/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                    # scriptable

Not 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

NOTE

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.

NOTE

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 tools
auth_statusA
Read-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_pagesA
Read-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_propertiesA
Read-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_reportA
Read-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_periodsA
Read-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_urlA
Read-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_sitemapsA
Read-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_sitesA
Read-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_analyticsA
Read-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_sitemapA
Destructive

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_submitA
Destructive

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_keyA
Read-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_reportA
Read-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

    A4.2/5.0

    Scored across 13 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count5/5

    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.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables querying Google Search Console and Google Analytics 4 through natural language, with tools for SEO analysis like anomaly detection, cannibalization detection, and opportunity scoring.
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables querying Google Search Console data, including search analytics with advanced filtering, quick wins detection, and rich dimensions, through natural language.
      9,552 npm
      MIT