mcp-site-analyst
Provides tools to run custom reports, retrieve realtime data, discover metadata, and access top pages, traffic sources, and demographics from Google Analytics GA4.
Provides tools to query search performance, inspect URLs, list/manage sitemaps, list sites, and access top queries and pages from Google Search Console.
Click on "Install 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., "@mcp-site-analystWhat are my top pages this week?"
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.
MCP Site Analyst
An MCP (Model Context Protocol) server that provides Google Analytics (GA4) and Google Search Console data as tools for AI assistants.
Features
13 tools across two Google services
Google Analytics (GA4): Custom reports, realtime data, metadata discovery, top pages, traffic sources, demographics
Google Search Console: Search analytics, sitemaps, URL inspection, site listing, top queries, top pages
Dual transport: stdio (local) and stateless HTTP (remote)
Flexible auth: Service account key file, inline JSON credentials, Application Default Credentials, or CLI argument
Configurable GA4 Property ID: Set once at server level or per-tool call
Optional Bearer token auth for HTTP mode
Related MCP server: ga4-mcp
Prerequisites
Google Cloud Project with these APIs enabled:
Service Account with a downloaded JSON key file:
Create a service account → Keys → Add Key → JSON
Grant access to the service account:
GA4: Admin > Property Access Management > Add the service account email as Viewer
Search Console: Settings > Users and permissions > Add the service account email
Installation
npm install
npm run buildUsage
stdio mode (Claude Desktop, Gemini CLI, etc.)
# Using CLI argument
node build/index.js --key-file /path/to/key.json
# Using environment variable
GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json node build/index.js
# With a default GA4 Property ID
node build/index.js --key-file /path/to/key.json --property-id 123456789HTTP mode
# Default port 3000
node build/index.js --http --key-file /path/to/key.json
# Custom port
node build/index.js --http --port 8080 --key-file /path/to/key.json
# With Bearer token authentication
MCP_AUTH_TOKEN=my-secret-token node build/index.js --http --key-file /path/to/key.jsonThe HTTP endpoint is available at POST http://localhost:3000/mcp (Streamable HTTP, stateless).
A health check endpoint is available at GET http://localhost:3000/health.
Authentication
The server resolves Google credentials in this order:
Priority | Method | Description |
1 |
| CLI argument pointing to a service account JSON key file |
2 |
| Environment variable containing the full JSON key as a string (useful for containers/CI) |
3 |
| Environment variable pointing to a key file path |
4 | Application Default Credentials | Automatic on Cloud Run, GCE, or when authenticated via |
Claude Desktop Configuration
Add to your claude_desktop_config.json:
{
"mcpServers": {
"site-analyst": {
"command": "node",
"args": [
"/absolute/path/to/mcp-site-analyst/build/index.js",
"--key-file",
"/absolute/path/to/key.json",
"--property-id",
"YOUR_GA4_PROPERTY_ID"
]
}
}
}Gemini CLI Configuration
Add to your .gemini/settings.json:
{
"mcpServers": {
"site-analyst": {
"command": "node",
"args": [
"/absolute/path/to/mcp-site-analyst/build/index.js",
"--key-file",
"/absolute/path/to/key.json"
]
}
}
}Remote HTTP Configuration
If deployed to a remote server (e.g. Cloud Run), configure your client to use the HTTP endpoint:
{
"mcpServers": {
"site-analyst": {
"httpUrl": "https://your-service-url/mcp",
"headers": {
"Authorization": "Bearer YOUR_AUTH_TOKEN"
}
}
}
}Deploying to Cloud Run
A deployment script is included for Google Cloud Run.
Setup
# Copy the example env file and fill in your values
cp .env.example .env
# Edit .env with your GCP project ID, region, and GA4 property IDSee .env.example for all available configuration options.
Deploy
# Deploy with Cloud Build (no local Docker required)
./deploy.sh --cloud-build
# Deploy with local Docker build
./deploy.sh
# Deploy with Bearer token auth enabled
./deploy.sh --token "my-secret-token"On Cloud Run the server uses Application Default Credentials automatically via the configured service account — no key file is needed.
Tools Reference
Google Analytics (GA4)
Tool | Description |
| Run a custom report with flexible dimensions, metrics, date ranges, filters, and sorting |
| Get real-time active user data (last 30 minutes) |
| Discover all available dimensions and metrics |
| Shortcut: Top pages by pageviews |
| Shortcut: Top traffic sources by sessions |
| Shortcut: User breakdown by country/city/language |
Google Search Console
Tool | Description |
| Query search performance (clicks, impressions, CTR, position) with filters |
| List all submitted sitemaps |
| Get details for a specific sitemap |
| Inspect a URL's index status and mobile usability |
| List all sites accessible by the service account |
| Shortcut: Top search queries by clicks |
| Shortcut: Top pages by clicks in search |
Development
# Run in dev mode (no build step needed)
npx tsx src/index.ts --key-file /path/to/key.json
# Build
npm run build
# Test with MCP Inspector
npx @modelcontextprotocol/inspector node build/index.js --key-file /path/to/key.jsonLicense
MIT
Available Tools
13 toolsga4_get_metadataA
List all available dimensions and metrics for a GA4 property. Use this to discover what fields are available before running reports.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Optional text filter to search dimension/metric names (case-insensitive) | |
| propertyId | No | GA4 Property ID. Use "0" to get common metadata across all properties. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It states that the tool lists metadata, implying a read-only operation, but does not elaborate on response format, pagination, or edge cases like the '0' propertyId. Minimal but not misleading.
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 two sentences long, with the first stating the core purpose and the second providing usage guidance. Every word earns its place; no redundant information.
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 low-complexity metadata listing tool with no required parameters and no output schema, the description sufficiently covers the 'what' and 'when'. It could mention the propertyId '0' special case, but that detail is already in the schema, making the description adequate overall.
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 schema provides 100% coverage of both parameters with clear descriptions. The description adds no parameter-specific semantics beyond what the schema already states, so it stays at the baseline of 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 uses a specific verb ('List') and resource ('available dimensions and metrics for a GA4 property'), clearly distinguishing it from sibling report and search tools. It states exactly what the tool does without ambiguity.
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?
It explicitly says 'Use this to discover what fields are available before running reports', giving clear context for when to use the tool. It does not explicitly name alternatives, but the sibling tools are clearly report-oriented, making the intended usage obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ga4_realtime_reportA
Get real-time active users and metrics from GA4. Shows data from the last 30 minutes.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum rows to return | |
| metrics | No | Realtime metric names, e.g. ["activeUsers", "screenPageViews"] | |
| dimensions | No | Realtime dimension names, e.g. ["city", "country", "unifiedScreenName"] | |
| propertyId | No | GA4 Property ID. If omitted, uses server-configured default. |
TDQS
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 the 30-minute real-time window, but omits other behavioral details such as whether the operation is read-only, response format, pagination, or permission requirements. Some useful context is added, but not enough for a higher score.
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 two sentences, direct, and front-loaded with the key action and resource. Every word earns its place, with no redundant or vague phrasing.
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?
The description is adequate for a simple real-time metrics tool, but with no output schema, it could benefit from explaining what the response looks like or any limitations. Still, the combination of description and fully-described parameters covers the essentials.
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 has 100% coverage with descriptions for all four parameters, so the baseline of 3 applies. The description does not add additional parameter semantics beyond the schema, which is acceptable given the schema's richness.
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 uses a specific verb ('Get'), identifies the resource ('real-time active users and metrics from GA4'), and adds a clear temporal scope ('last 30 minutes'). This distinguishes it from sibling tools like ga4_run_report, which would handle historical data.
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 clearly implies real-time use cases by specifying the 30-minute window, giving an agent context on when to choose this tool. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ga4_run_reportA
Run a custom GA4 report with flexible dimensions, metrics, and date ranges. Use ga4_get_metadata to discover available dimensions and metrics first.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of rows to return (default: 100, max: 100000) | |
| offset | No | Row offset for pagination (default: 0) | |
| endDate | Yes | End date in YYYY-MM-DD format, or relative: "today", "yesterday" | |
| metrics | Yes | Metric names, e.g. ["activeUsers", "sessions", "screenPageViews", "bounceRate"] | |
| orderBys | No | Order-by specifications | |
| startDate | Yes | Start date in YYYY-MM-DD format, or relative: "today", "yesterday", "7daysAgo", "30daysAgo" | |
| dimensions | No | Dimension names, e.g. ["city", "country", "pagePath", "sessionSource"] | |
| propertyId | No | GA4 Property ID (numeric). If omitted, uses server-configured default. | |
| metricFilter | No | JSON string of a metric filter expression. Example: {"filter":{"fieldName":"activeUsers","numericFilter":{"operation":"GREATER_THAN","value":{"int64Value":"10"}}}} | |
| dimensionFilter | No | JSON string of a dimension filter expression. Example: {"filter":{"fieldName":"country","stringFilter":{"value":"United States"}}} |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears the full burden but adds little beyond purpose. The metadata prerequisite is a useful behavioral hint, but it doesn't disclose output format, error behavior, or rate limits. The term 'report' implies read-only, but this isn't explicit.
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 consists of two sentences: one for purpose and one for the key prerequisite. It is front-loaded, concise, and every sentence earns its place with no redundancy.
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?
The tool has 10 parameters and no annotations, but the schema provides rich parameter descriptions. The description covers basic purpose and metadata discovery but omits when to use simpler predefined reports and lacks return value context. It is minimally adequate but not fully complete for a complex tool.
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 baseline is 3. The description adds value by telling the agent to use ga4_get_metadata to discover valid dimension and metric names, which is essential for correct parameter usage. This goes beyond the schema's static examples.
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 'Run a custom GA4 report' with a specific verb and resource. It distinguishes from siblings like ga4_top_pages and ga4_realtime_report by emphasizing 'custom' and flexible dimensions/metrics/date ranges.
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 provides clear usage context by instructing to 'Use ga4_get_metadata to discover available dimensions and metrics first,' which sets a prerequisite and points to a sibling tool. It implies this is for custom reports but doesn't explicitly list exclusions or alternative tools, so it's clear but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ga4_top_pagesA
Get the top pages by page views for a GA4 property. A convenient shortcut for a common report.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of top pages to return (default: 20) | |
| endDate | No | End date (default: today) | today |
| startDate | No | Start date (default: 30daysAgo) | 30daysAgo |
| propertyId | No | GA4 Property ID |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only states what the tool returns (top pages by page views) but gives no information about authorization needs, rate limits, data freshness, or any side effects. For a read-only report tool, this is a notable gap.
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 two sentences and gets straight to the point. 'A convenient shortcut for a common report' adds practical context without waste. No redundancy or fluff.
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?
The tool is simple, all parameters are documented, and the description clarifies the report type. There is no output schema, so the description could have elaborated on the returned fields, but for a straightforward 'top pages' report, the current description is sufficient. The defaults and date range are handled by the schema.
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 all four parameters having clear descriptions and defaults. The description's phrase 'top pages by page views' adds context about the metric, but it does not meaningfully enhance the parameter semantics beyond what the schema already provides. 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 uses a specific verb 'Get' and clearly identifies the resource: 'top pages by page views for a GA4 property.' It distinguishes itself from sibling tools like ga4_run_report by framing itself as a 'convenient shortcut for a common report.'
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 provides clear context: it is a shortcut for a common report, implying use when you need a quick top-pages list rather than a custom-built report. However, it does not explicitly name alternative tools like ga4_run_report or state when not to use this tool, so it misses the top tier.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ga4_top_traffic_sourcesA
Get top traffic sources for a GA4 property, broken down by source/medium.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of sources to return (default: 20) | |
| endDate | No | End date (default: today) | today |
| startDate | No | Start date (default: 30daysAgo) | 30daysAgo |
| propertyId | No | GA4 Property ID |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility. It mentions the breakdown by source/medium but does not disclose read-only nature, return format, error behavior, or any limitations. This leaves the agent without crucial behavioral context for a data retrieval tool.
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, front-loaded sentence with no redundant wording. It efficiently conveys the core purpose without any 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?
The tool has no output schema, and the description fails to clarify what metric defines 'top' (e.g., sessions or users) or what the response structure looks like. For a simple query tool, this missing information is a significant gap.
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 all parameters are documented in the schema. The description does not add any extra meaning beyond what the schema already states for propertyId, dates, and limit, so the baseline score of 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 function: 'Get top traffic sources for a GA4 property, broken down by source/medium.' It uses a specific verb and resource, and the 'broken down by source/medium' detail differentiates it from sibling tools like ga4_top_pages (which focuses on pages) and GSC tools.
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 provides clear context: use this tool when you need top traffic sources by source/medium. However, it does not explicitly mention alternatives or when not to use it, such as comparing with ga4_run_report, so it lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ga4_user_demographicsA
Get user demographics breakdown (country, city, or language) for a GA4 property.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of results to return (default: 20) | |
| endDate | No | End date (default: today) | today |
| dimension | No | Demographic dimension to break down by (default: country) | country |
| startDate | No | Start date (default: 30daysAgo) | 30daysAgo |
| propertyId | No | GA4 Property ID |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description alone must convey behavioral traits. It only says 'get', implying read-only, but does not disclose potential limitations, required permissions, date handling, or what the response contains. This minimal transparency leaves significant assumptions.
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 of 11 words, directly stating the tool's purpose. It is perfectly front-loaded and contains no unnecessary verbiage, earning a top score for conciseness.
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?
The description is adequate for a simple query tool, especially with complete schema parameter documentation. However, with no output schema and no annotations, it lacks guidance on return format, date usage, and required propertyId, leaving some gaps in completeness.
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 all parameters are already documented. The description adds marginal value by listing 'country, city, or language' which matches the dimension enum, but it does not provide additional meaning or usage context beyond the schema.
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 function: getting user demographics breakdown by country, city, or language for a GA4 property. This distinguishes it from sibling tools like ga4_top_pages or ga4_run_report, which have different focuses.
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 for demographic breakdowns but does not explicitly state when to use it versus alternatives or mention any exclusions. There is no direct comparison to sibling tools, though the tool name and description provide enough context for an informed guess.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gsc_get_sitemapB
Get detailed information about a specific sitemap.
| Name | Required | Description | Default |
|---|---|---|---|
| siteUrl | Yes | Site URL as registered in Search Console | |
| feedpath | Yes | Full URL of the sitemap (e.g. "https://example.com/sitemap.xml") |
TDQS
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 merely says 'get detailed information' without specifying what details are included, how the response is structured, or whether the operation has any side effects. This is a minimal disclosure.
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, front-loaded sentence with zero wasted words. It conveys the essential purpose efficiently, achieving high conciseness and clean structure.
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?
The tool has no output schema and no annotations, so the description must compensate. It does not explain what 'detailed information' means, what the response contains, or any edge cases. Compared to the richer context in sibling tools, this description is incomplete.
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 description adds no parameter information, but the input schema provides full descriptions for both siteUrl and feedpath (100% coverage). The baseline for high coverage is appropriate, so the description need not duplicate schema details.
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 ('get') and resource ('sitemap'), with the scope 'specific' which directly distinguishes it from the sibling tool gsc_list_sitemaps. This is a specific verb+resource+scope formulation.
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 for retrieving details on a single sitemap, but it does not explicitly state when to use it over alternatives like gsc_list_sitemaps or gsc_inspect_url, nor does it mention any preconditions or contexts where it should not be used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gsc_inspect_urlA
Inspect a URL in Google Search Console. Returns indexing status, crawl info, mobile usability, and rich results status. Note: daily quotas apply.
| Name | Required | Description | Default |
|---|---|---|---|
| siteUrl | Yes | Site URL as registered in Search Console | |
| languageCode | No | Language code for the response | en-US |
| inspectionUrl | Yes | The fully-qualified URL to inspect |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It adds a useful note about daily quotas and lists the response dimensions. However, it does not explicitly confirm that the operation is read-only, nor does it mention authorization requirements or potential error conditions. The quota and return-type details provide some coverage, but gaps remain.
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 exactly two sentences: the first states the core purpose and return categories, and the second adds a critical quota warning. It is front-loaded, free of fluff, and every sentence adds value.
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?
The description is reasonably complete for a read-only inspection tool: it names the key result areas and mentions daily quotas, which is a practical constraint. It lacks an output schema but the description covers the main categories. It could be improved by noting that siteUrl must be a verified property or by clarifying output structure, but overall it is adequate.
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 already provides 100% coverage with descriptions for each parameter (siteUrl, inspectionUrl, languageCode). The description adds no additional meaning beyond what the schema already states, 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Inspect a URL') and the resource (Google Search Console), and it enumerates the kinds of data returned (indexing status, crawl info, mobile usability, rich results status). This distinguishes it from sibling tools like gsc_search_analytics or gsc_list_sitemaps, which serve different purposes.
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 when you need URL-level inspection data from GSC, but it does not explicitly contrast with alternatives or state when not to use it. There is no mention of using other tools for aggregate analytics or sitemap management, leaving the decision to the agent's inference from sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gsc_list_sitemapsA
List all sitemaps submitted to Google Search Console for a site.
| Name | Required | Description | Default |
|---|---|---|---|
| siteUrl | Yes | Site URL as registered in Search Console |
TDQS
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 states the operation is a list (implying a non-destructive read), but it does not disclose details like response format, pagination, or whether it returns only submitted sitemaps or all discovered ones. Given the simplicity, it meets the minimum but lacks extra behavioral context.
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, focused sentence with no redundant words. It efficiently conveys the tool's purpose and scope.
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 list tool with one parameter, the description covers the core purpose adequately. However, it does not mention what the output looks like (e.g., URLs only vs. additional metadata), and there is no output schema to fill that gap. Since the tool is straightforward, a score of 4 is reasonable.
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 coverage is 100% for the single parameter siteUrl, which already has a clear description. The tool description adds little beyond the schema, merely restating 'for a site.' Baseline 3 is appropriate since the schema does the heavy lifting.
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 uses a specific verb ('List') and clearly identifies the resource ('sitemaps submitted to Google Search Console') and scope ('for a site'). It distinguishes itself from siblings like gsc_get_sitemap (which likely handles a single sitemap) and gsc_list_sites (which lists sites).
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 a straightforward use case (when you need all sitemaps for a site) but provides no explicit guidance on when to choose this tool over alternatives such as gsc_get_sitemap. No exclusions or alternative tool references are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gsc_list_sitesA
List all sites the service account has access to in Google Search Console.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. 'List' clearly indicates a read-only operation with no side effects, and the service account scope is useful context. However, it does not disclose potential behavior like pagination, return format, or authentication nuances. It stops at the basic functionality, which is sufficient for a simple tool but not rich in behavioral detail.
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, focused sentence that states the action, resource, and scope. It contains no filler or redundancy. Every word contributes meaning, making it highly efficient and easy to parse.
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 parameterless list tool, the description provides adequate context. It explains what the tool returns (sites) and the access scope. While it does not detail the exact fields in the response (e.g., site URL, permission level), the absence of an output schema and the simplicity of the operation keep the description reasonably complete. A longer description could add examples of returned data, but it is not essential.
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 takes zero parameters, and the input schema is empty with 100% schema coverage. The description does not need to explain parameters. Per the rubric, a tool with 0 parameters receives a baseline score of 4, and there is nothing additional to document.
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 function: 'List all sites the service account has access to in Google Search Console.' It uses a specific verb (List), identifies the resource (sites), and adds the scoping detail of service account access. This distinguishes it from sibling tools like search analytics or sitemap tools.
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 clearly implies usage: to retrieve sites accessible to the service account, use this tool. While it does not explicitly mention when not to use it or name alternative tools, the context is unambiguous for a simple list operation. It could have been more explicit about integration with other gsc_* tools, but the core context is conveyed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gsc_search_analyticsB
Query Google Search Console search analytics data. Returns clicks, impressions, CTR, and average position. Can be broken down by query, page, country, device, or date.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Search type filter (default: "web") | web |
| endDate | Yes | End date in YYYY-MM-DD format | |
| siteUrl | Yes | Site URL as registered in Search Console. Use full URL for URL-prefix properties (e.g. "https://example.com/") or "sc-domain:example.com" for domain properties. | |
| rowLimit | No | Maximum rows to return (default: 100, max: 25000) | |
| startRow | No | Starting row for pagination | |
| dataState | No | Data freshness: "all" includes fresh data, "final" only verified data | all |
| startDate | Yes | Start date in YYYY-MM-DD format | |
| dimensions | No | Dimensions to group by (default: ["query"]) | |
| dimensionFilterGroups | No | Filter groups to narrow results. Example: [{"filters":[{"dimension":"query","operator":"contains","expression":"keyword"}]}] |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden for behavioral disclosure. It mentions return metrics and grouping options, but omits important behaviors such as pagination (rowLimit/startRow), data freshness (dataState), filtering behavior, sampling, or rate limits. This is a notable gap for an API with these capabilities.
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 two sentences, front-loaded with the core purpose. It is concise and directly conveys the essential function and key return values without unnecessary fluff.
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?
This is a complex 9-parameter tool with no output schema and no annotations. The description covers only the basics (metrics and dimensions) but omits return structure details, pagination behavior, filter usage, and data freshness considerations. For a tool of this complexity, the description is insufficient to fully prepare an agent for correct usage.
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 all 9 parameters are already documented in the schema. The description adds a general statement about breakdown dimensions ('query, page, country, device, or date') which merely echoes the dimensions enum, providing no additional parameter-level meaning beyond the schema.
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 uses a specific verb ('Query') and resource ('Google Search Console search analytics data'), and further specifies the metrics returned and grouping dimensions. This clearly distinguishes it from sibling tools like gsc_top_queries and gsc_top_pages, which are likely specialized subsets.
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 clearly states the tool queries search analytics data, which is the primary use case, but provides no explicit guidance on when to use alternatives like gsc_top_queries or gsc_top_pages. No exclusions or comparisons are mentioned, leaving the choice implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gsc_top_pagesB
Get top pages by clicks in Google Search for a site. A convenient shortcut.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of top pages to return (default: 25) | |
| endDate | No | End date (default: today) | 2026-08-01 |
| siteUrl | Yes | Site URL as registered in Search Console | |
| startDate | No | Start date (default: 30 days ago) | 2026-07-02 |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of disclosing behavior. It only states 'Get top pages by clicks,' which implies a read-only operation, but it does not disclose pagination behavior, return format, or whether the data is limited to specific date ranges beyond schema defaults. The 'convenient shortcut' phrase is vague and does not explain what is being abstracted away. There is no mention of ownership or permission requirements, making this minimally transparent.
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, focused sentence that delivers the purpose immediately. 'A convenient shortcut' is a harmless, clarifying fragment. There is no redundancy or filler, making it well-structured and concise. Every word earns its place.
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?
The tool is a simple read-only list endpoint with only one required parameter, and the schema covers all parameters with defaults. However, there is no output schema, and the description does not specify the shape of the returned data (e.g., does it include impressions, position, or just URL and clicks?). The phrase 'convenient shortcut' is unhelpful without explaining what alternate tool or report it wraps. Given the lack of annotations and output schema, the description is adequate but leaves room for ambiguity about the returned fields and edge cases.
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 baseline is 3. The description itself adds minimal parameter meaning beyond what the schema already provides—it does not explain how 'siteUrl' relates to the 'site' mentioned, nor does it clarify 'limit' or date formatting. Since the schema already documents all four parameters and the description offers no additional context, a score of 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 function: 'Get top pages by clicks in Google Search for a site.' It uses a specific verb (Get), identifies the resource (top pages), and includes the metric (clicks) and context (for a site). This distinguishes it from siblings like gsc_top_queries (queries vs pages) and gsc_search_analytics (more general). The phrase 'convenient shortcut' adds context that it simplifies a more complex operation.
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 provides no explicit guidance on when to use this tool versus alternatives. 'A convenient shortcut' hints that it is a simpler alternative to a more granular tool (likely gsc_search_analytics), but it does not name the alternative or specify conditions for use. No exclusions or prerequisites are mentioned, so the agent gets only a vague sense of when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gsc_top_queriesB
Get top search queries by clicks for a site. A convenient shortcut for common analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of top queries to return (default: 25) | |
| endDate | No | End date (default: today) | 2026-08-01 |
| siteUrl | Yes | Site URL as registered in Search Console | |
| startDate | No | Start date (default: 30 days ago) | 2026-07-02 |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure. It mentions the metric ('by clicks') but does not state that it is a read-only operation, that site verification is required, or that results are limited top queries only. The date range behavior is only in the schema, not in the description.
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 two sentences, front-loads the core purpose, and contains no redundant information. Every word contributes to understanding the tool's function.
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 shortcut tool, the description is adequate but does not clarify what is omitted relative to the full search analytics tool (e.g., custom dimensions, filters, grouping). Since there is no output schema, a bit more context about return format would improve completeness.
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 schema provides 100% description coverage for all parameters, so the baseline is 3. The description adds no additional parameter-level semantics; it simply confirms the main focus on top queries by clicks.
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 returns top search queries by clicks for a site, using a specific verb and resource. However, it does not explicitly differentiate from sibling tools like gsc_search_analytics or gsc_top_pages, causing minor ambiguity.
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 'convenient shortcut for common analysis' implies a simpler use case but does not explicitly state when to use this tool versus alternatives like gsc_search_analytics for custom queries. No 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.
TDQS
Tools are cleanly separated by service prefix (ga4_ vs gsc_) and each targets a distinct function. Even the top_pages tools are unambiguous because one is GA4 page views and the other is GSC search clicks, with clear descriptions noting they are conveniences over more general reporting tools.
All tools follow a consistent lower_snake_case pattern with service prefixes, and the action or data focus is clear. While some names omit explicit verbs (e.g., ga4_top_pages), the pattern is uniform across the set, making it easy to infer behavior.
13 tools is well within the ideal range for a focused analytics server, covering both GA4 and GSC without redundancy. Each tool earns its place by providing a distinct, useful capability for site analysis.
The tool surface covers core analytics needs for both GA4 (demographics, realtime, custom reports, metadata, common metrics) and GSC (search performance, sitemaps, URL inspection, site listing). Minor gaps exist, such as no explicit GA4 property listing or advanced GSC sitemap submission, but these do not block typical analysis workflows.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
SEO MCP server for keyword research, SERP analysis, audits, and Search Console workflows.
MCP server for querying and analyzing data from ad platforms, analytics tools, and spreadsheets
Clamp Analytics MCP server: traffic, revenue, funnels, cohorts, errors, and search, for AI agents.
MCP server for building and testing AI agents with multi-model experimentation and insights.
Related MCP Servers
- AlicenseAqualityCmaintenanceMCP server that gives AI assistants live access to Google Search Console and Bing Webmaster Tools for search performance, indexing, keyword research, and crawl health analysis directly in the chat.1018MIT
- AlicenseBqualityDmaintenanceAn MCP server integrating Google Analytics 4, Search Console, and Indexing API, enabling AI agents to run reports, inspect URLs, manage properties, and request indexing.16155MIT
- AlicenseNot gradedqualityCmaintenanceAn MCP server that connects AI assistants to SEO platforms like Google Search Console, GA4, Bing Webmaster Tools, and Adobe Analytics, enabling natural language queries about SEO performance.2,926MIT
- AlicenseNot gradedqualityDmaintenanceA unified MCP server that gives AI assistants direct access to Google Analytics 4, Google Search Console, Google Ads and Google Merchant Center data using OAuth2 user credentials.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/danishm/mcp-site-analyst'
If you have feedback or need assistance with the MCP directory API, please join our Discord server