SearchLink Lite
Provides tools for interacting with Google Search Console, enabling queries about site performance, search analytics, indexing status, sitemaps, and opportunities.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@SearchLink LiteHow did example.com do on Google in the last 28 days?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
SearchLink Lite
Google Search Console inside Claude, Cursor and any MCP client. Runs on your machine, read-only, free (MIT).
Ask things like:
"How did example.com do on Google in the last 28 days?"
"Which pages lost the most clicks?"
"Which queries get impressions but no clicks?"
"Is https://example.com/pricing indexed?"
Tools
Tool | What it answers |
| Which sites are in your Search Console |
| Clicks, impressions, CTR, position vs the previous period, biggest drops and gains, up to 3 things to do now |
| Any breakdown by query, page, country, device or date, with filters and period comparison |
| High impressions but low CTR, queries ranking #8-20, pages losing clicks |
| Is this page indexed, last crawl, Google's canonical |
| Sitemap status, errors and URL counts |
Totals come from the date dimension, so they match the Search Console UI. (Summing page rows double-counts impressions.)
Related MCP server: SearchConsole.ai
Setup (about 10 minutes)
You need a Google credentials file that can read Search Console. A service account is the most reliable option.
In Google Cloud Console, pick or create a project and enable the Google Search Console API.
Go to IAM & Admin > Service accounts, create one (no roles needed), then Keys > Add key > JSON. Save the file somewhere safe.
In Search Console, open Settings > Users and permissions > Add user, paste the service account email, and choose Restricted. Repeat for each site.
Add the server to your client (below), pointing
GOOGLE_APPLICATION_CREDENTIALSto the JSON file.
Already use gcloud? This also works instead of steps 1-3:
gcloud auth application-default login --scopes=https://www.googleapis.com/auth/webmasters.readonly,https://www.googleapis.com/auth/cloud-platformClaude Desktop
In claude_desktop_config.json:
{
"mcpServers": {
"searchlink": {
"command": "npx",
"args": ["-y", "github:GlobalMatchHub/searchlink-lite"],
"env": { "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/key.json" }
}
}
}Claude Code
claude mcp add searchlink -e GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json -- npx -y github:GlobalMatchHub/searchlink-liteCursor
In ~/.cursor/mcp.json, use the same block as Claude Desktop.
Requires Node.js 18 or newer.
Privacy
Everything runs locally. Your credentials and data go only to Google's APIs. Nothing is sent to us.
Want it without the setup?
SearchLink is the hosted version: sign in with Google (no key files), and it adds Bing Webmaster data (beta), Copilot citation tracking, page speed, a one-screen dashboard, a Monday email with 3 things to fix, and alerts when clicks drop. Works in Claude, ChatGPT and Cursor. Free for 1 site.
License
MIT
Available Tools
6 toolsfind_opportunitiesFind opportunitiesBRead-only
Queries with many impressions but few clicks (fix title/description), queries ranking #8-20 (close to the top), and pages losing clicks.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Length of the period in days (compared with the period right before it). | |
| site | Yes | Your site, e.g. "example.com". Use list_sites to see options. | |
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only nature is covered. The description adds context on the kind of opportunities returned, which is useful, but it does not disclose behaviors like pagination, data freshness, or how results are structured.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that efficiently packs the key criteria into a concise list. It is front-loaded and contains no filler, though it could be split for readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, and the description does not explain the format of the returned opportunities or how the agent should act on them. It also lacks any usage context, such as whether results are aggregated or time-series. This makes the description inadequate for an agent to fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 67% (site and days have descriptions, limit does not). The description does not mention any parameters or how they influence the results, so it adds no value beyond the schema. Baseline for this coverage level is 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool identifies opportunities: queries with high impressions but low clicks, queries ranking #8-20, and pages losing clicks. This is specific and distinguishes it from raw data tools like search_performance, though it does not explicitly name sibling alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool over alternatives such as search_performance or site_overview. The description only lists the types of opportunities, leaving the agent to infer when this tool is the right choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
inspect_urlCheck if a page is indexedARead-only
Google URL Inspection: is this URL indexed, when was it crawled, which canonical Google chose, and any blocking issue.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Full page URL | |
| site | Yes | Your site, e.g. "example.com". Use list_sites to see options. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, and the description adds meaningful behavioral context by specifying exactly what kind of information will be returned: indexed status, crawl time, canonical choice, and blocking issues. This goes beyond the annotations, though it does not discuss error conditions or freshness limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single dense sentence that front-loads the core purpose and quickly enumerates the key outputs. There is no filler or redundant elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-required-parameter read-only tool, the description covers the essential return categories even without an output schema. It is complete enough for an agent to know what to expect, though a note about response shape or failure modes would make it fully self-sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both `site` and `url` already documented. The description does not add parameter-level detail beyond the schema, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly names the resource (a specific URL) and the operation (Google URL Inspection), and enumerates what it answers: indexed status, crawl date, Google-chosen canonical, and blocking issues. This differentiates it from sibling site-level tools like site_overview and search_performance without needing to inspect their schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the clear use case: investigate a specific page's indexing and blocking status in Google. It does not explicitly state when not to use it or name alternatives, but the context is strong enough that an agent can reasonably select this tool for per-URL diagnostics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_sitesList my sitesARead-only
List the websites in your Google Search Console.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe read-only nature is covered structurally. The description adds little beyond restating the listing behavior and the data source, providing no extra context about response shape or scope.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with no wasted words. It front-loads the action and resource, which is exactly appropriate for a tool this simple.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only listing tool, the description is essentially complete: it names the exact data source and action. It could optionally mention what the returned list contains, but the lack of output schema does not create a significant gap at this complexity level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no parameter semantics burden on the description. Schema coverage is trivially complete, and the baseline of 4 for zero-parameter tools applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('List') and resource ('websites in your Google Search Console'), making the purpose unmistakable. It does not, however, explicitly distinguish itself from siblings like site_overview or search_performance, though its name and title already convey the listing function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives such as site_overview or search_performance. The description simply states what it does, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_performanceSearch performance (custom)BRead-only
Flexible Search Console query. Group by query, page, country, device or date; filter by text; optionally compare with the previous period.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Length of the period in days (compared with the period right before it). | |
| site | Yes | Your site, e.g. "example.com". Use list_sites to see options. | |
| limit | No | ||
| sort_by | No | clicks | |
| group_by | No | ||
| filter_page | No | Only pages whose URL contains this text. | |
| filter_query | No | Only queries containing this text. | |
| compare_previous | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, covering the safety profile. The description adds that it can optionally compare with the previous period, which is a behavioral detail, but it does not disclose output format, pagination, or rate limits. It does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, dense sentence that front-loads the purpose and then lists capabilities. Every phrase earns its place, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only query tool with no output schema, the description covers the primary features but omits details like sorting and limits, which are available in the schema. It is functional but not exhaustive for a tool with 8 parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 50%, and the description compensates for key parameters like group_by (lists grouping dimensions), filter_page/filter_query ('filter by text'), and compare_previous ('compare with the previous period'). It does not add value for sort_by or limit, but those have defaults and enums, so the partial compensation is adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies this as a flexible Search Console query for performance data, listing grouping, filtering, and comparison options. It is specific enough to distinguish from siblings like site_overview, though it does not explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through its listed capabilities (grouping, filtering, comparing) but gives no explicit guidance on when to use this tool over siblings like site_overview or find_opportunities. An agent can infer when it is appropriate, but there are no exclusions stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sitemapsSitemap statusBRead-only
Sitemaps submitted to Google: last read, errors, warnings, URL counts.
| Name | Required | Description | Default |
|---|---|---|---|
| site | Yes | Your site, e.g. "example.com". Use list_sites to see options. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true and openWorldHint=true, and the description does not contradict them. It adds useful context about the returned status fields, but it does not disclose potential limitations such as data freshness, pagination, or whether the result includes all sitemaps. This is modest added value beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, with no filler words. It is more of a labeled phrase than a complete sentence, but every phrase communicates a meaningful aspect of the tool's output.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read-only tool, the description plus annotations and schema cover the core invocation details. However, with no output schema and no usage guidance, the agent must infer when this tool is appropriate compared to sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully describes the only parameter, site, with an example and a pointer to list_sites. The description itself adds no parameter-specific meaning, but the schema already carries the entire semantic burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the specific resource ('Sitemaps submitted to Google') and the data shown ('last read, errors, warnings, URL counts'), making the tool's function fairly clear. It lacks an explicit verb like 'list' or 'get', and does not explicitly differentiate from sibling tools, but the resource is distinct enough.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus siblings like site_overview or inspect_url. The intended context is implied—checking sitemap submission status—but no explicit conditions, exclusions, or alternative recommendations are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
site_overviewSite overviewARead-only
Clicks, impressions, CTR and average position vs the previous period, the pages that gained or lost the most, and up to 3 things to do now. Start here.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Length of the period in days (compared with the period right before it). | |
| site | Yes | Your site, e.g. "example.com". Use list_sites to see options. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds useful behavior: comparison against the previous period, pages that gained/lost, and up to 3 recommendations. It does not disclose deeper behaviors like data limits, pagination, or interpretation caveats, but given the read-only annotation the safety profile is covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the key metrics and ends with a clear call to action. Every phrase contributes information, with no filler or repetition of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter overview tool, the description covers the main output elements: key metrics, comparison period, page changes, and recommendations. There is no output schema, so the description reasonably conveys what the agent can expect. It does not detail return formatting or exact comparison calculations, but these are minor for this tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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. The description's 'vs the previous period' aligns with the days parameter but adds no new semantic detail beyond what the schema already states. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's content: clicks, impressions, CTR, average position, top gaining/losing pages, and recommendations. It is distinct from siblings like inspect_url or search_performance by describing a site-level overview, though it does not explicitly name alternatives or use a strong imperative verb.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'Start here' gives explicit guidance that this is the entry-point tool for site analysis. It establishes clear context for when to use it, but it does not mention when not to use it or explicitly route to alternatives such as find_opportunities or search_performance.
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.
6 tool updates
v0.1.0- First observed
find_opportunities - First observed
inspect_url - First observed
list_sites - First observed
search_performance - First observed
site_overview - First observed
sitemaps
TDQS
Scored across 6 tools
Each tool targets a distinct aspect of Search Console data: site list, overview, opportunities, raw performance, URL inspection, and sitemaps. There is some overlap between site_overview, find_opportunities, and search_performance, but their purposes are differentiated by level of detail and intent.
Tool names mix verb-first patterns (list_sites, find_opportunities, inspect_url) with noun phrases (site_overview, sitemaps) and an ambiguous case (search_performance). This makes names less predictable, though they are still readable and specific.
Six tools is well within the ideal range for a focused Search Console lite server. Each tool covers a meaningful area without redundancy or bloat.
The set covers all major Search Console data surfaces: site list, performance analytics, URL inspection, and sitemaps, plus value-added opportunity and overview tools. For a lite read-only analytics server, there are no significant gaps.
Maintenance
Related MCP Connectors
Read-only Search Console analytics, URL inspection, indexing diagnostics, and sitemaps.
Google Search Console MCP for analytics, indexing, sitemaps, and SEO diagnostics.
Read Search Console performance, keyword opportunities and annotations for your sites.
Read and edit GA4, Search Console and Google Tag Manager from any MCP client. 29 tools.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceRead-only MCP server that gives AI clients access to Google Search Console data, enabling natural language queries about traffic, rankings, and SEO opportunities.103 npmMIT
- AlicenseNot gradedqualityBmaintenanceRead-only MCP server for Google Search Console data, enabling search analytics, URL inspection, indexing diagnostics, and sitemap management through MCP clients.18 npmMIT
- AlicenseBqualityBmaintenanceEnables Google Search Console data queries via MCP, including search analytics, performance comparisons, URL inspection, and sitemap management.12MIT
- AlicenseNot gradedqualityCmaintenanceProvides read-only access to Google Search Console data, including search analytics, sitemap status, and URL inspection, for MCP clients like Claude.5 npmMIT