ScreenshotNeo
Sign in Get a free key

BlogAI agents

Google Search Console MCP

Connect an MCP client to Search Console for analytics, URL inspection, sitemaps and sites— with OAuth, quotas, deployment and troubleshooting explained.

By the ScreenshotNeo team1 October 20268 min read

Google Search Console MCP is an MCP server that gives an AI host access to Google Search Console APIs. It does not create new SEO data. The agent uses the permissions of its authenticated identity to query Search Analytics, inspect URLs, manage sitemaps and manage Search Console properties.

The official MCP Registry lists io.github.mikusnuz/gsc version 1.3.1 as a local server for Search Analytics, sitemaps and URL inspection. Treat that implementation as community-maintained: Google’s public google/mcp repository catalog does not list a Google-managed Search Console server.

What Google Search Console MCP can do

Search Console area Typical agent actions
Search Analytics Query clicks, impressions, CTR and position over a required date range, grouped or filtered by dimensions such as country, device, page and query.
Sitemaps List, retrieve, submit or delete sitemaps.
Sites List, add, remove or inspect properties available to the authenticated identity.
URL Inspection Check the indexed status and inspection result for a specific URL.

Search Analytics responses are sorted by click count. Google limits the result set internally and does not guarantee that every matching row is returned, so treat results as top rows rather than a complete export.

Is there an official Google Search Console MCP server?

Not in the catalog covered by this guide. The registry entry above is a community implementation. Google does publish MCP projects and managed MCP infrastructure, but its displayed official catalog does not include a Search Console server.

Before connecting a community server, inspect its source, release history, dependency changes and credential handling. Confirm which tools it exposes and whether write operations such as sitemap submission or property changes require an explicit approval step.

How the connection works

  1. Your MCP client (Claude, Cursor, Gemini or another MCP host) starts a local server over stdio, or connects to a remote server over HTTP.
  2. The server authenticates to Google APIs using OAuth or another supported identity.
  3. Google evaluates that identity’s Search Console permissions and OAuth scopes.
  4. The MCP server translates the model’s tool call into a Search Console API request and returns the API response to the host.

Local servers normally run on the same machine as the client and communicate over stdio. Remote servers run on service infrastructure and expose authenticated HTTP connections. Google’s managed MCP platform adds discovery, toolsets, IAM policies, authentication and Model Armor controls. Google release notes state that managed Google and Google Cloud MCP servers reached general availability in May 2026, while individual servers can still be Preview or GA.

Set up a Search Console MCP connection

1. Choose and review the server

Start with the registry identifier io.github.mikusnuz/gsc, then review the project source and release history. Do not grant credentials until you understand where tokens are stored, which hosts receive requests and which tools can change Search Console state.

2. Create Google credentials

Create or select credentials in the Google API environment used by your organization. Grant the narrowest scope that fits the work:

  • https://www.googleapis.com/auth/webmasters.readonly for read-only analytics, URL inspection, sites and sitemap reads.
  • https://www.googleapis.com/auth/webmasters when the workflow must submit or delete sitemaps, add or remove sites, or perform other write operations.

Use a dedicated identity where possible. Its permissions determine which Search Console properties an agent can access.

3. Connect the server to your MCP host

The exact configuration keys depend on the client and the server release. A local stdio configuration has this general shape; replace placeholders with the command documented by the server you selected:

{
  "mcpServers": {
    "google-search-console": {
      "command": "YOUR_SERVER_COMMAND",
      "args": ["YOUR_SERVER_ARGUMENTS"],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "/secure/path/credentials.json"
      }
    }
  }
}

For a remote deployment, configure the MCP client with the server’s HTTPS endpoint and its required OAuth or service identity settings. Keep credentials in the host’s secret store rather than committing them to a repository.

4. Verify with read-only calls

  1. List accessible properties.
  2. Run a one-day Search Analytics query with a small dimension set.
  3. Inspect one known URL.
  4. List sitemaps without submitting or deleting anything.

Only after those checks should you enable workflows that change sitemaps or properties.

Search Analytics query design

Every Search Analytics query needs a date range of at least one day. Add only the dimensions needed for the question. Common dimensions include date, country, device, page and query. Filters can narrow the result set.

Start with short ranges and inexpensive groupings. Grouping or filtering by page and query, and requesting longer date ranges, increases API load. Cache repeated questions in your application or agent workflow.

POST https://www.googleapis.com/webmasters/v3/sites/{siteUrl}/searchAnalytics/query
Content-Type: application/json
Authorization: Bearer ACCESS_TOKEN

{
  "startDate": "2026-09-01",
  "endDate": "2026-09-07",
  "dimensions": ["query", "page"],
  "rowLimit": 100
}

URL-encode the property value when it is placed in a path. For a domain property, use the property format expected by the Search Console API.

Runnable API examples

The MCP server is the convenient agent interface. These direct API examples are useful for validating credentials, reproducing a problem and building a fallback integration.

cURL: Search Analytics

curl -X POST \
  "https://www.googleapis.com/webmasters/v3/sites/https%3A%2F%2Fexample.com%2F/searchAnalytics/query" \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startDate": "2026-09-01",
    "endDate": "2026-09-07",
    "dimensions": ["query"],
    "rowLimit": 25
  }'

Python: Search Analytics

import os
import requests

site = "https://example.com/"
endpoint = "https://www.googleapis.com/webmasters/v3/sites/" + requests.utils.quote(site, safe="") + "/searchAnalytics/query"
body = {
    "startDate": "2026-09-01",
    "endDate": "2026-09-07",
    "dimensions": ["query", "device"],
    "rowLimit": 25,
}
response = requests.post(
    endpoint,
    headers={
        "Authorization": f"Bearer {os.environ['ACCESS_TOKEN']}",
        "Content-Type": "application/json",
    },
    json=body,
    timeout=30,
)
response.raise_for_status()
print(response.json())

Node.js: Search Analytics

const site = 'https://example.com/';
const endpoint = 'https://www.googleapis.com/webmasters/v3/sites/' + encodeURIComponent(site) + '/searchAnalytics/query';
const res = await fetch(endpoint, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.ACCESS_TOKEN}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    startDate: '2026-09-01',
    endDate: '2026-09-07',
    dimensions: ['page'],
    rowLimit: 25
  })
});
if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
console.log(await res.json());

URL Inspection request

POST https://searchconsole.googleapis.com/v1/urlInspection/index:inspect
Authorization: Bearer ACCESS_TOKEN
Content-Type: application/json

{
  "inspectionUrl": "https://example.com/article",
  "siteUrl": "https://example.com/"
}

Use the MCP tool for this operation when available; the direct request is a diagnostic fallback.

Quotas, performance and cost

Resource Documented quota Operational advice
Search Analytics, per site 1,200 queries per minute Batch related dimensions, cache repeated requests and use short date ranges while developing.
Search Analytics, per user 1,200 queries per minute Coordinate agents that share one identity.
URL Inspection, per site 2,000 queries per day and 600 per minute Queue inspections, deduplicate URLs and stop retry loops.

Google Search Console API access itself is not priced per request in the supplied documentation, but your MCP hosting, logging and model provider may have separate costs. Remote deployments also add infrastructure and network overhead.

Reliability checklist

  • Set request timeouts and exponential backoff for transient failures.
  • Cache identical analytics queries and URL inspections.
  • Record the property, date range, dimensions, filters and identity for every call.
  • Preserve the raw response so an analyst can review model summaries.
  • Require confirmation before sitemap deletion, sitemap submission or property changes.
  • Design around top-row Search Analytics responses; do not treat them as exhaustive exports.

Troubleshooting

Symptom Likely cause Fix
401 Unauthorized Expired, missing or invalid access token. Refresh OAuth credentials and verify the token is sent as a Bearer token.
403 Forbidden The identity lacks the required Search Console property permission or OAuth scope. Grant property access to the correct identity and use webmasters.readonly or webmasters as appropriate.
Empty analytics results No data matches the property, date range or filters, or the property format is wrong. Test a one-day range without filters and confirm the exact property URL.
Missing rows Search Analytics returns top rows under internal limits. Reduce dimensions, split the date range and avoid assuming the response is a complete export.
429 or quota errors Per-user, per-site or URL Inspection limits were exceeded. Back off, cache, deduplicate and queue requests.
MCP tools do not appear The client cannot start the local process or reach the remote endpoint. Run the server command manually, inspect stderr and verify the client’s configuration and environment variables.
Write action changes the wrong property The agent selected an unintended property available to the identity. Pass the property explicitly and require human confirmation for destructive operations.

Security and deployment guidance

  • Prefer read-only OAuth until a write workflow is proven.
  • Use a narrowly scoped identity and review its list of Search Console properties.
  • Keep tokens outside source control and rotate them when staff or infrastructure changes.
  • For remote MCP, enforce HTTPS, authenticate every request and restrict network access.
  • Log tool calls without logging client secrets or refresh tokens.
  • Review model-generated sitemap or property operations before execution.

Or skip the browser setup

If your workflow also needs screenshots of pages, ScreenshotNeo provides a website screenshot API and MCP server. It accepts one GET request and returns PNG, JPEG, WebP or PDF. Cookie and consent banners, newsletter popups and chat widgets are removed before capture; bot checks, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and billing status. Its MCP server exposes take_screenshot, get_page_info and capture_pdf for Claude, Cursor and other MCP clients.

See the ScreenshotNeo API documentation for all options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

1,000 screenshots per month are free with no card. Paid plans start at $5 for 3,000 screenshots, and every feature is available on every plan. Create a free ScreenshotNeo account.

FAQ

Can I connect Search Console MCP to Claude, Cursor or Gemini?

Yes, if the host supports MCP and the server’s local stdio or remote HTTP transport. Configure the server using the host’s documented MCP settings.

Does MCP bypass Search Console permissions?

No. Google authorizes every request using the identity connected to the server.

Can it inspect URLs and query keywords?

Yes. Search Analytics supports query and page dimensions, and URL Inspection checks a specific URL’s indexing status.

Why is my report incomplete?

Search Analytics returns top rows under Search Console’s internal limits. Split queries and treat results as bounded samples unless your export design accounts for that limitation.

Should I use local or remote MCP?

Use local stdio for a single developer workstation. Use authenticated remote HTTP when several users or automated agents need a centrally governed service.

Keep reading