Google Search Console MCP Server: Setup for Claude, Cursor, ChatGPT

A Google Search Console MCP server exposes the Search Console API as tools an AI client can call, so Claude, Cursor or ChatGPT can answer “which queries lost clicks this month?” or “is this URL indexed?” from your own data. As of October 2026, Google hasn't published one: Search Console isn't on Google's list of Google-managed MCP servers. Every option is a third-party wrapper: open source and run on your machine with your own Google Cloud credentials, or hosted, with the Google sign-in handled for you.

This guide compares the main servers, gives a working config for each client, and covers what the Search Console API can't do. That last part matters as soon as you want an agent to act on indexing instead of reading analytics.

What a Search Console MCP server can reach

Every GSC MCP server sits on top of the same Search Console API, so the API sets the ceiling. It has four resources:

• Search Analytics: one query method for clicks, impressions, CTR and position, grouped by query, page, country, device, search appearance, date or hour.
• Sitemaps: list, get, submit and delete.
• Sites: list, get, add and delete properties.
• URL Inspection: index.inspect, which returns Google's view of one URL. The result includes a verdict, the coverageState phrase, robotsTxtState, lastCrawlTime, pageFetchState, and the canonical you declared (userCanonical) next to the one Google chose (googleCanonical).

Two things are missing, and they are the ones people expect most. There is no method for Request indexing: the button exists only in the URL Inspection tool in the Search Console interface. And the API only reads the indexed version: Google's method reference says you can't test the indexability of a live URL with it, while the interface has Test live URL.

Some servers add a “submit URL to Google” tool built on the Indexing API instead. Google's quickstart says it can only be used for pages with JobPosting or a BroadcastEvent embedded in a VideoObject, so using it for other pages is outside Google's documented use (more in the Google Indexing API guide).

Here is how common requests map onto the API:

Quotas an agent will run into

Google's usage limits allow 1,200 Search Analytics queries per minute per site and per user, and 2,000 URL inspections per day (600 per minute) per site. An agent that inspects every page of a large site in one session stops at the daily quota, and an inspection only tells you the state at that moment, not how it changed.

The Search Analytics method returns 1,000 rows by default and at most 25,000 per request, paged with startRow. Ask a server for “all queries” and you get the first 1,000 unless it pages. Its dataState defaults to final, which leaves out fresh data that all includes. mcp-gsc defaults to all to match the dashboard, according to its README. When an agent's numbers don't match the Performance report, compare this setting first.

Open-source vs hosted Google Search Console MCP servers

MCP directories list many Search Console servers. Most follow one of two patterns: a local server you start with your own Google credentials, or a hosted or managed server that keeps the Google token for you. These are representative of each, as of October 2026:

• mcp-gsc (MIT, about 2,100 GitHub stars) runs with uvx mcp-search-console. It signs in through an OAuth client of type Desktop app or a service account. Its README counts 20 tools. The ones that add or delete a site, or delete a sitemap, stay off unless you set GSC_ALLOW_DESTRUCTIVE to true, which is a sensible default for an agent.
• mcp-server-gsc (MIT) needs Node 18 or later and a service account key in GOOGLE_APPLICATION_CREDENTIALS. It documents a single tool, so there is less for the model to choose from if all you want is performance data.
• Composio hosts a Search Console toolkit with nine tools and its own Google OAuth app. Its page lists a free Hobby plan with 100,000 tool calls a month, of which up to 20,000 can go through Composio-managed apps such as this one.
• Mintive offers a managed connector where each user signs in with their own Google account, so tool calls are bounded by the property permissions they already have. It requests the indexing scope as well, and its documentation notes that the Indexing API only accepts job posting and livestream pages, in line with Google's rules.

Which one to pick

• Performance analysis on a few properties, and Google Cloud doesn't scare you: an open-source server. It is free, local, and the credentials stay on your machine.
• No Google Cloud project, or a client that can't send an API key header, like ChatGPT: a hosted server that signs you in with OAuth.
• An agent that keeps pages indexed after each deploy: you need index status stored over time, IndexNow for other engines and a path to Request indexing. Search Analytics servers don't cover any of that. Run an indexing server next to an analytics one: clients load several servers at once.

For crawling, rank and backlink servers as well, see the wider list of SEO MCP servers, or the best MCP servers for developers in general.

Set up Google credentials for a self-hosted server

Local servers call the API as you, so they need a Google Cloud project with the Search Console API enabled and one of two credentials, as mcp-gsc's README describes:

1. An OAuth client of type Desktop app. A browser window opens on first use, you sign in, and the server caches the token. Best for your own properties.
2. A service account key. No browser. Add the service account's email in Search Console under Settings → Users and permissions with Full access, on every property it should read.

Three details to get right:

• Weekly sign-ins. If your OAuth consent screen uses the external user type and is still in testing, Google issues refresh tokens that expire after 7 days. The server works for a week, then asks you to sign in again. Publish the app or use a service account.
• The property name. A Domain property is sc-domain:example.com. A URL-prefix property is the exact URL with a trailing slash, such as https://www.example.com/. An inspected URL must belong to the property you name.
• The scope. Search Analytics and URL Inspection accept the read-only webmasters.readonly scope. Submitting a sitemap requires the full webmasters scope, so grant it only if you want the agent to change things.

The Google Search Console API guide covers the API itself, and the URL Inspection API guide covers inspection fields and quotas in depth.

Connect Search Console to Claude, Cursor, ChatGPT and other clients

There are two ways to attach a server. A local (stdio) server is a command the client starts, with credentials in environment variables. A remote server is a URL the client calls over Streamable HTTP, with credentials in a header or an OAuth sign-in. The MCP specification defines both; the remote MCP server guide explains the difference.

The examples below use mcp-gsc as the local server and IndexCyborg's endpoint as the remote one. Swap in another server's command or URL and the shape stays the same.

Claude Code

From the Claude Code docs: a local server takes --env for its variables and everything after -- as its command; a remote one takes --transport http and --header.

claude mcp add --env GSC_OAUTH_CLIENT_SECRETS_FILE=/full/path/to/client_secrets.json \
  --transport stdio gsc -- uvx mcp-search-console

claude mcp add --transport http indexcyborg https://indexcyborg.com/api/mcp \
  --header "Authorization: Bearer ic_your_key"

Add --scope user to use a server in every project, or --scope project to write it to .mcp.json for your team. That file expands environment variables, so the key doesn't have to be committed:

{
  "mcpServers": {
    "indexcyborg": {
      "type": "http",
      "url": "https://indexcyborg.com/api/mcp",
      "headers": { "Authorization": "Bearer ${INDEXCYBORG_API_KEY}" }
    }
  }
}

More in the Claude Code MCP setup guide.

Claude Desktop and claude.ai

To connect Google Search Console to Claude through a remote server, open Customize → Connectors, add a custom connector with the server URL, and, for a key-based server, add an Authorization header with the value Bearer ic_your_key under Request headers. According to Anthropic's help center, custom connectors are available on every plan (one on Free), and the calls come from Anthropic's cloud, so the server must be reachable over the public internet. On Team and Enterprise, an owner adds the connector under Organization settings → Connectors, and a key in Request headers gives everyone who uses the connector that key's access.

Local servers go in claude_desktop_config.json instead. mcp-gsc recommends the full path to uvx, because desktop apps don't read your shell configuration:

{
  "mcpServers": {
    "gsc": {
      "command": "/full/path/to/uvx",
      "args": ["mcp-search-console"],
      "env": { "GSC_OAUTH_CLIENT_SECRETS_FILE": "/full/path/to/client_secrets.json" }
    }
  }
}

Details in the Claude Desktop MCP guide.

Cursor

Cursor reads .cursor/mcp.json in the project and ~/.cursor/mcp.json globally, and resolves ${env:NAME} in URLs and headers. One file can hold an analytics server and an indexing server side by side:

{
  "mcpServers": {
    "gsc": {
      "command": "/full/path/to/uvx",
      "args": ["mcp-search-console"],
      "env": { "GSC_OAUTH_CLIENT_SECRETS_FILE": "/full/path/to/client_secrets.json" }
    },
    "indexcyborg": {
      "url": "https://indexcyborg.com/api/mcp",
      "headers": { "Authorization": "Bearer ${env:INDEXCYBORG_API_KEY}" }
    }
  }
}

Step by step in the Cursor MCP guide.

VS Code and GitHub Copilot

VS Code uses a top-level servers key in .vscode/mcp.json. An inputs entry with "password": true prompts for the key once and stores it securely:

{
  "inputs": [
    { "type": "promptString", "id": "indexcyborg-key", "description": "IndexCyborg API key", "password": true }
  ],
  "servers": {
    "indexcyborg": {
      "type": "http",
      "url": "https://indexcyborg.com/api/mcp",
      "headers": { "Authorization": "Bearer ${input:indexcyborg-key}" }
    }
  }
}

See the VS Code MCP guide for agent mode.

Codex CLI and Gemini CLI

Codex reads ~/.codex/config.toml and can take the bearer token from an environment variable:

[mcp_servers.indexcyborg]
url = "https://indexcyborg.com/api/mcp"
bearer_token_env_var = "INDEXCYBORG_API_KEY"

Gemini CLI uses httpUrl for Streamable HTTP (url means SSE there) and has an add command. Its default scope is the project, so the key lands in .gemini/settings.json: keep that file out of version control, or pass --scope user to write ~/.gemini/settings.json instead.

gemini mcp add --transport http \
  --header "Authorization: Bearer ic_your_key" \
  indexcyborg https://indexcyborg.com/api/mcp

Full walkthroughs: Codex MCP and Gemini CLI MCP.

ChatGPT

As of October 2026, OpenAI's guide adds a custom server on ChatGPT web from Plugins, with the Add custom MCP server option. It supports SSE and streaming HTTP, and lists OAuth or no authentication. Write actions ask for confirmation by default. The guide lists no option for a static API key or bearer header, so ChatGPT works with Search Console servers that sign you in with OAuth, not with key-based servers such as IndexCyborg's. The full process is in connect Google Search Console to ChatGPT.

Windsurf, Cline and Zed

Each takes a remote URL and headers in its own config file, with its own key names. Check the client's current docs, or follow the Windsurf MCP, Cline MCP and Zed MCP guides.

Beyond analytics: index status, IndexNow and Request indexing

Search Analytics tells you how indexed pages perform. It says nothing about pages that aren't indexed, because they have no impressions. Three jobs need more than a Search Analytics wrapper.

Index status for every page, over time

Inspection answers for one URL at a time, at the moment you ask, inside the daily quota. To answer “which pages aren't indexed, and since when?”, something has to inspect the whole sitemap on a schedule and keep Google's answers. Those answers are phrases such as Crawled - currently not indexed, Discovered - currently not indexed and Duplicate, Google chose different canonical than user, the same wording as the Page indexing report. A page nobody inspected is unknown, not indexed, and a coverage figure should say how many pages were inspected.

Notifying other search engines

Bing, Yandex, Seznam.cz, Naver, Yep and others take URL notifications through IndexNow; Google is not on the list of participating engines. The IndexNow FAQ says a submission doesn't guarantee indexing: each engine still decides whether and when to crawl, so an accepted notification is not a crawl. See what IndexNow is and IndexNow MCP for the agent side.

Asking Google to crawl a page

Without an API, the only route is the Request indexing button. Google's recrawl guide says there is a quota for individual URLs, that requesting the same URL again won't make it faster, and that crawling can take from a few days to a few weeks. A request puts the URL in a crawl queue; it is not an index entry. Request indexing in Search Console covers the manual flow, and Google indexing MCP covers doing it from an agent.

Prompts that use these jobs, with an analytics server and an indexing server connected:

• “Compare clicks for /blog pages over the last 28 days against the 28 days before, and list pages that lost more than half.”
• “For these ten URLs, show where the canonical Google chose differs from the one we declared.”
• “Which pages are Crawled - currently not indexed, and what do they have in common?”
• “I just deployed /docs/webhooks and /docs/retries. Notify IndexNow and queue both for Request indexing.”

Before you connect a server

• Trust. OpenAI's guide puts it plainly: only connect to MCP servers you trust, since an untrusted server can access what you share or steer the model into misusing tools. The same holds in every client.
• Write tools. Prefer read-only scopes and servers that keep destructive tools off by default. Read the tool list before you approve it.
• Secrets. Service account keys and API keys are credentials. Use your client's variable expansion or input prompts instead of pasting them into committed files.
• Hosted tokens. A hosted server holds a Google token for your properties. Check which scopes it asks for and how you revoke it.

For when an agent should use MCP and when a pipeline should call a REST API directly, see MCP vs API.

How IndexCyborg's MCP server handles indexing

IndexCyborg runs a remote, stateless MCP server at https://indexcyborg.com/api/mcp, authenticated with a scoped API key (read, notify, manage, optionally limited to some websites). You link Search Console once by OAuth in the dashboard, with no Google Cloud project of your own. It reads your sitemaps, inspects new pages straight away and re-checks them after 7 days, within Google's 2,000-a-day quota, and stores coverageState word for word. get_unindexed_pages lists only inspected pages, and generate_indexing_report states coverage against the inspected population. notify_search_engines queues an IndexNow notification for up to 1,000 URLs once your domain and key are verified. request_google_indexing queues up to 50 URLs per call for the IndexCyborg Chrome extension, which you load from the dashboard's Settings and which clicks Request indexing in your own Search Console session, at most 10 per property per rolling 24 hours. The full tool list is in check indexing with MCP.

It doesn't read Search Analytics: no clicks, impressions or queries. Pair it with one of the analytics servers above if you want both. And it can't make Google index anything: a queued URL waits for the extension, and a requested URL is in Google's crawl queue, nothing more. The features page covers the dashboard side, and pricing lists the plans.

Frequently asked questions