Skip to main content
Glama
wyattxmgmt

GSC MCP Server

by wyattxmgmt

Google Search Console MCP Server

A Model Context Protocol (MCP) server for Google Search Console — connect it to Claude Desktop, Claude Code, or any other MCP-compatible client and ask questions about your site's search analytics (clicks, impressions, CTR, position), sitemaps, and indexing status directly in chat.

What it can do

Tool

Description

list_sites

List every property the authenticated account can access

query_search_analytics

Query clicks, impressions, CTR, and position — grouped by query, page, country, device, or date, with optional filters

list_sitemaps

List sitemaps submitted for a property

get_sitemap

Get status/details for one sitemap

submit_sitemap

Submit a new sitemap

delete_sitemap

Remove a sitemap

inspect_url

Run the URL Inspection tool (indexing status, coverage issues, mobile usability) on a single URL

Related MCP server: mcp-gsc

Requirements


1. Create a Google Cloud project and enable the API

  1. Go to the Google Cloud Console and create a new project (top bar → project dropdown → New Project). Give it any name, e.g. GSC Connection.

    Creating a new Google Cloud project

  2. With that project selected, open APIs & Services → Library, search "Google Search Console API", and click Enable.

Everything below branches by auth method — pick one.


Uses your own Google login, so it automatically sees every property you personally have access to. Requires a one-time browser authorization.

Configure the consent screen:

  1. Go to APIs & Services → OAuth consent screen (in the newer Cloud Console this is under Google Auth Platform → Branding, part of a 4-step setup wizard).

  2. App information: enter an app name (e.g. GSC MCP Server) and your email as the support email → Next.

    OAuth consent screen App Information step

  3. Audience: choose ExternalNext.

  4. Contact information: enter your email → Next.

  5. Finish: accept the policy → Create.

  6. On the Audience page that follows, scroll to Test users → Add users, and add your own Google account's email. While the app is unpublished ("Testing" status), only test users can complete the login — this is expected and fine to leave as-is indefinitely for personal use.

    Adding a test user under Audience settings

Create the OAuth client:

  1. Go to Clients (left sidebar) → Create client.

  2. Application type: Web application (not "Desktop" — this project's local auth flow expects a fixed redirect URI, which only the Web application type lets you set).

  3. Name it anything, e.g. GSC MCP.

  4. Under Authorized redirect URIs, click Add URI and enter exactly:

    http://localhost:53682/oauth2callback

    Creating the OAuth client ID as a Web application

  5. Click Create, then download the client JSON (via the download icon next to the client in the Clients list).

  6. Save the downloaded file into this project's folder as oauth-credentials.json.

    oauth-credentials.json saved in the project folder

Configure and authorize:

  1. Copy .env.example to .env and set (use absolute paths — see the note below):

    GSC_OAUTH_CREDENTIALS_PATH=/absolute/path/to/google-search-console-mcp-server/oauth-credentials.json
    GSC_OAUTH_TOKEN_PATH=/absolute/path/to/google-search-console-mcp-server/.gsc-token.json
  2. Run the one-time login:

    npm run auth

    This prints a URL — open it in your browser, log in with the account you added as a test user, and approve access. The CLI saves a token to .gsc-token.json and you're done; you won't need to repeat this unless the token is deleted or access is revoked.

Why absolute paths? .env paths are resolved relative to the current working directory of whatever process launches the server — that's your shell when you run npm run dev, but it's a different, unpredictable directory when an app like Claude Desktop spawns the server for you. Relative paths (./oauth-credentials.json) can silently fail to resolve in that case, causing an unexplained "no credentials" error. Absolute paths always work regardless of who launches the process.

2b. Option B — Service account (no browser login, better for servers/CI)

  1. In Cloud Console, go to APIs & Services → Credentials → Create Credentials → Service account.

  2. Give it any name (e.g. gsc-mcp) and click Done (no project-level roles needed).

  3. Open the new service account → Keys tab → Add Key → Create new key → JSON. Save the downloaded file into this project's folder, e.g. gsc-service-account.json.

  4. Copy the service account's email address (looks like gsc-mcp@your-project.iam.gserviceaccount.com).

  5. In Google Search Console, open the property → Settings → Users and permissions → Add user → add the service account's email as a Full user. Repeat for every property you want this server to see.

  6. In .env (absolute path, same reasoning as above):

    GSC_SERVICE_ACCOUNT_KEY_PATH=/absolute/path/to/google-search-console-mcp-server/gsc-service-account.json

3. Install and build

git clone https://github.com/wyattxmgmt/google-search-console-mcp-server.git
cd google-search-console-mcp-server
npm install
npm run build

(You should already have .env set up from section 2a or 2b above.)


4. Connect it to an MCP client

Claude Desktop

The current Claude Desktop app manages local MCP servers under Settings → Developer → Local MCP servers, not under Settings → Connectors (Connectors there is for remote/hosted MCP servers reachable over HTTPS — a locally-run server like this one won't show up there).

  1. Open Settings → Developer → Local MCP servers → Edit Config. This opens claude_desktop_config.json directly.

  2. Add a mcpServers entry (merge with whatever's already in the file — don't replace it):

    {
      "mcpServers": {
        "gsc": {
          "command": "node",
          "args": [
            "--env-file=/absolute/path/to/google-search-console-mcp-server/.env",
            "/absolute/path/to/google-search-console-mcp-server/dist/index.js"
          ]
        }
      }
    }
  3. Save, then fully quit Claude Desktop (not just close the window — use the tray/taskbar icon) and reopen it.

  4. Check Settings → Developer → Local MCP servers again — gsc should show status running.

    gsc server showing status running under Local MCP servers

Claude Code

Copy .mcp.json.example to .mcp.json in this project and fill in the absolute path:

{
  "mcpServers": {
    "gsc": {
      "command": "node",
      "args": ["--env-file=.env", "dist/index.js"],
      "cwd": "/absolute/path/to/google-search-console-mcp-server"
    }
  }
}

Open Claude Code in this directory — it'll prompt you to approve the project-scoped gsc server on first load. To make it available in every session regardless of directory, register it globally instead:

claude mcp add gsc --scope user -- node --env-file=/absolute/path/to/google-search-console-mcp-server/.env /absolute/path/to/google-search-console-mcp-server/dist/index.js

Any other MCP client

The server speaks standard MCP over stdio — point your client at node dist/index.js with the same environment variables set (or --env-file), and it will work the same way.


Example prompts once connected

Troubleshooting

  • "No credentials configured" — you need exactly one of GSC_SERVICE_ACCOUNT_KEY_PATH or GSC_OAUTH_CREDENTIALS_PATH set in .env.

  • "No cached OAuth token found" — run npm run auth first.

  • Works with npm run dev but fails/times out when launched by Claude Desktop — almost always relative paths in .env. Switch to absolute paths (see the callout in 2a).

  • Empty results from list_sites — the account/service-account tied to your credentials hasn't been added as a user on any property in Search Console.

  • 403 errors on a specific site — double check the exact siteUrl format Search Console uses for that property (e.g. sc-domain:example.com for domain properties vs. https://example.com/ for URL-prefix properties) — see it via list_sites.

  • Google shows "app isn't verified" / blocks login — expected while the OAuth consent screen is in "Testing" status. Make sure the Google account you're logging in with was added under Audience → Test users.

Development

npm run dev    # run directly with tsx, no build step
npm run build  # compile to dist/

License

MIT

Available Tools

7 tools
delete_sitemapDelete sitemapA

Remove a sitemap from Google Search Console for a property.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteUrlYesThe property URL as registered in Search Console
feedpathYesFull URL of the sitemap, e.g. https://example.com/sitemap.xml

TDQS

A3.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description must carry full behavioral disclosure. 'Remove' implies a destructive action, but the description does not state whether the action is irreversible, whether special permissions are required, or what happens if the sitemap does not exist.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, focused sentence with no redundant or irrelevant information. Every word contributes to the meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple delete operation with two well-specified parameters, the description covers the core action. However, with no annotations, it could benefit from noting permanence or side effects, though it remains minimally viable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with both siteUrl and feedpath clearly documented. The description adds no additional meaning beyond the schema, providing no further guidance on syntax or format.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action ('Remove') on a specific resource ('sitemap') within a clear context ('Google Search Console for a property'). It clearly distinguishes from sibling tools like submit_sitemap and list_sitemaps by focusing on deletion.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly implies usage when a sitemap needs to be removed from a property. It provides clear context but does not explicitly state alternatives or when not to use it, nor mention prerequisites like the sitemap having been previously submitted.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_sitemapGet sitemap detailsA

Get details and status for a single sitemap.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteUrlYesThe property URL as registered in Search Console
feedpathYesFull URL of the sitemap, e.g. https://example.com/sitemap.xml

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the burden. It explicitly says 'get', indicating a read operation, which is a basic behavioral trait. However, it does not disclose error handling, prerequisites, or return format, leaving some gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that directly states the tool's function. No unnecessary words or repetition of the tool name; it earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has no output schema, no annotations, and the description does not explain what 'details and status' specifically include. It also lacks behavior context like what happens if the sitemap does not exist. Given the vague wording, the description is insufficient for a fully informed agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage for both parameters (siteUrl and feedpath), each with clear definitions. The description adds no extra parameter semantics, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool gets details and status for a single sitemap, using the specific verb 'get' and resource 'single sitemap'. This differentiates it from sibling tools like list_sitemaps (plural) and submit_sitemap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description conveys that this is for a single sitemap, implying you should know the specific sitemap URL. While it does not explicitly mention alternatives like list_sitemaps, the context is clear enough that an agent would know when to use this tool versus listing all sitemaps.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

inspect_urlInspect URLA

Run the Search Console URL Inspection tool on a single URL to check indexing status, coverage issues, mobile usability, and more.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteUrlYesThe property URL as registered in Search Console
languageCodeNoBCP-47 language code for the response, defaults to en-US
inspectionUrlYesThe full URL to inspect

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It discloses the types of checks performed (indexing, coverage, mobile usability) and implies a read-only inspection, but lacks details on response format, potential errors, authentication, or rate limits. This is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that front-loads the action and purpose, with no wasted words. It efficiently communicates the core functionality.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description lists the key inspection categories (indexing status, coverage issues, mobile usability, and more), which is sufficient for an agent to understand the tool's breadth. It could be more explicit about return data, but the tool's scope is moderate and the description is adequately complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with descriptions for all three parameters (siteUrl, languageCode, inspectionUrl). The description adds little beyond stating 'single URL,' so it meets the baseline but does not enhance parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Run the Search Console URL Inspection tool' and clearly identifies the resource (a single URL) and the purpose (check indexing status, coverage issues, mobile usability). It effectively distinguishes itself from sibling tools that deal with sitemaps and analytics.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for inspecting a single URL, which is clear given sibling tools focus on different tasks (sitemaps, analytics, site listing). However, it does not explicitly state when not to use it or mention alternatives, so it stops short of full guidelines.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_sitemapsList sitemapsA

List all sitemaps submitted for a Search Console property.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteUrlYesThe property URL as registered in Search Console

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden of disclosing behavior. It correctly indicates a read-only listing operation and notes that only submitted sitemaps are included, but it does not mention return format, pagination, permissions, or side effects. The coverage is adequate for a simple list tool but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no redundant words. Every word contributes to the meaning, making it appropriately concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the low complexity (one parameter, no output schema, no annotations), the description sufficiently covers the core purpose. It could be more complete by mentioning the return type or that it only returns submitted sitemaps, but for a straightforward list operation, it is largely complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% (siteUrl is well-described as 'The property URL as registered in Search Console'). The tool description adds no additional meaning beyond the schema's parameter explanation, so the baseline score of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('List all sitemaps') and the scope ('for a Search Console property'). It distinguishes from sibling tools like get_sitemap (singular) and submit/delete sitemap by emphasizing it lists all submitted sitemaps.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for viewing all submitted sitemaps but does not explicitly mention when to use this tool versus alternatives such as get_sitemap. No exclusions or alternative tools are referenced, leaving usage guidance mostly implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_sitesList Search Console sitesA

List all sites/properties the authenticated account has access to in Google Search Console.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4.1/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It indicates a read-only operation by saying 'List' and 'has access to', but it does not mention rate limits, pagination, or output format. This is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, compact sentence that conveys all essential information without redundancy or extraneous detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple parameterless list operation with no output schema, the description fully covers what the tool does. The output is implied to be the list of sites, and the lack of parameters simplifies the context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so baseline is 4. The description correctly adds no parameter-specific semantics since there are none to explain.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'List' with a clear resource 'sites/properties' and scope 'the authenticated account has access to'. It clearly distinguishes from sibling tools like list_sitemaps, which lists sitemaps rather than properties.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this tool is the way to retrieve accessible Search Console properties, but it does not explicitly state when to use it over alternatives or mention exclusions. Usage context is inferred rather than directly guided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

query_search_analyticsQuery Search AnalyticsA

Query Google Search Console performance data (clicks, impressions, CTR, position) for a site, broken down by dimensions like query, page, country, device, or date.

ParametersJSON Schema
NameRequiredDescriptionDefault
endDateYesEnd date in YYYY-MM-DD format
filtersNoOptional filters to narrow results, combined with AND
siteUrlYesThe property URL as registered in Search Console, e.g. 'https://example.com/' or 'sc-domain:example.com'
rowLimitNoMax rows to return, defaults to 1000
startRowNoRow offset for pagination, defaults to 0
startDateYesStart date in YYYY-MM-DD format
dimensionsNoDimensions to group results by
searchTypeNoSearch type to filter on, defaults to web

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that the tool queries performance data broken down by dimensions, but does not mention pagination behavior, data limits, authorization requirements, or response format. The schema adds some behavioral details, but the description itself is thin.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, front-loaded sentence efficiently conveys the tool's purpose and key capabilities with no filler or repetition. It is appropriately sized for a query tool with a rich schema.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having 8 parameters and no output schema, the schema is very thorough, covering each parameter's meaning. The description is adequate for a read-oriented analytics query, but it does not mention return value shape or edge cases, which would have made it more complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 100% coverage of parameters with descriptions, so the baseline is 3. The description adds little beyond restating the dimensions concept already present in the schema, mostly echoing 'query, page, country, device, or date' without providing additional semantic meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool queries Google Search Console performance data with specific metrics (clicks, impressions, CTR, position) and dimensions, distinguishing it from sibling tools that manage sites, sitemaps, or inspect URLs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for performance data but does not explicitly state when to use this tool over alternatives, nor does it mention any exclusion conditions. Siblings are distinct enough that confusion is unlikely, but no direct guidance is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

submit_sitemapSubmit sitemapB

Submit a new sitemap to Google Search Console for a property.

ParametersJSON Schema
NameRequiredDescriptionDefault
siteUrlYesThe property URL as registered in Search Console
feedpathYesFull URL of the sitemap, e.g. https://example.com/sitemap.xml

TDQS

B3.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention prerequisites (e.g., property must exist), idempotency, side effects (e.g., overwriting or adding a new entry), or any return value. The description essentially restates the tool's name with minimal added context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, clear sentence that front-loads the action and resource. No wasted words or redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple action tool with no annotations and no output schema, the description should at least hint at expected behavior or usage context. It lacks guidance on when to use it and what happens after submission, leaving gaps that the schema cannot fill.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents both parameters (siteUrl and feedpath). The description adds no additional parameter semantics, but the schema already provides sufficient detail, meriting the baseline score of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Submit') and resource ('sitemap to Google Search Console for a property'), clearly distinguishing it from sibling tools like get_sitemap, delete_sitemap, and list_sitemaps.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. It doesn't mention that this is for adding a sitemap, or when not to use it (e.g., for updating existing sitemaps). The existence of sitemap-related siblings makes this absence notable.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 7 tool updatesv0.1.0
    • First observeddelete_sitemap
    • First observedget_sitemap
    • First observedinspect_url
    • First observedlist_sitemaps
    • First observedlist_sites
    • First observedquery_search_analytics
    • First observedsubmit_sitemap

TDQS

A4/5.0

Scored across 7 tools

Disambiguation5/5

Each tool targets a distinct resource and action: site listing, sitemap lifecycle (list/get/submit/delete), URL inspection, and search analytics querying. No overlap; get_sitemap vs list_sitemaps is clearly singular vs plural.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern: list_sites, get_sitemap, submit_sitemap, delete_sitemap, inspect_url, query_search_analytics, list_sitemaps. The style is uniform and predictable.

Tool Count5/5

7 tools is well-scoped for a Google Search Console server, covering the core resources (sites, sitemaps, URLs, analytics) without bloat. Each tool earns its place.

Completeness4/5

The sitemap lifecycle is complete (list, get, submit, delete), and URL inspection plus search analytics cover major GSC functions. A minor gap is the lack of a dedicated tool to get detailed property info beyond listing, but this is workable.

Maintenance

ActivitySlowing
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    D
    maintenance
    An MCP Server that provides access to Google's Search Console API, allowing users to interact with website search performance data and manage search presence through natural language.
    -
  • A
    license
    Not graded
    quality
    A
    maintenance
    MCP server for Google Search Console, enabling querying search analytics, URL inspection, sitemap management, and more via natural language.
    260 npm
    1
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    MCP server that exposes the Google Search Console API, allowing LLMs to query SEO data, inspect URLs, manage sitemaps, and analyze search performance via natural language.
    66 npm
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Self-hosted MCP server that connects Google Search Console to AI assistants, enabling natural language queries about search analytics, sitemaps, and URL inspection data.
    MIT