flin-google-ads-mcp
This is a read-only MCP server for Google Ads — no create, update, or delete operations are allowed. Here's what you can do:
Account & Customer Management
List all accessible customer accounts via OAuth credentials
Retrieve subaccounts under a manager (MCC) account, with optional name-based search
Campaign & Ad Structure
Get campaigns and ad groups, filterable by status or campaign ID
Retrieve ads including RSA content (headlines, descriptions, paths, final URLs)
Performance Insights
Get metrics (impressions, clicks, CTR, CPC, cost) at the campaign, ad group, ad, or account level
Supports preset date ranges (
TODAY,LAST_30_DAYS,THIS_MONTH, etc.) and customYYYY-MM-DDranges
Conversion Insights
View conversion-specific reporting segmented by day or conversion action
Keywords & Search Terms
Retrieve keyword-level entities with performance metrics
Fetch actual user search terms from the search term view
Change History
View recent account changes (resource, operation, old/new values) within a 30-day window
Authentication
Check OAuth status, generate an authorization URL, save a refresh token from an auth code, and clear stored tokens
Health Check
Verify server configuration and connectivity to the Google Ads API
Read-only access to Google Ads, providing tools for listing customers, campaigns, ad groups, ads, keywords, and insights (metrics) at various levels such as campaign, ad group, ad, customer, and account.
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., "@flin-google-ads-mcpget yesterday's account-level insights"
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.
flin-google-ads-mcp
Read-only MCP server for Google Ads, built for simple public use via uvx.
Why this server
Read-only by design
No create/update/delete campaign operations
Refresh token can be generated and stored through MCP auth tools
Easy local testing with MCP Inspector
Related MCP server: Google Ads MCP Server
Exposed MCP tools
health_checklist_accessible_customersget_customer_clientsfind_customer_clientsget_campaignsget_ad_groupsget_adsget_insightsget_conversion_insightsget_keywordsget_search_termsget_change_eventsauth_statusget_auth_urlsave_refresh_token_from_codeclear_auth_token
get_ads includes RSA content fields (headlines/descriptions/paths/final URLs) when available.
get_insights supports:
campaignad_groupadcustomer(account-level metrics)account(alias ofcustomer)
get_search_terms is backed by search_term_view, so it returns actual user search terms rather than configured keywords. Pass segment_by_date=true when you need daily search-term rows with a date field instead of one aggregate row per search term for the requested range.
Search-term conversion filters:
conversion_action_idconversion_action_name
Search-term optional segmentation:
segment_by_date
get_change_events is backed by the Google Ads change_event resource. It returns recent account changes with user, client type, changed resource, operation, changed field paths, and old/new values where the API returns them. Google Ads requires a finite change_event.change_date_time window within the past 30 days and a LIMIT; pass start_date and end_date as YYYY-MM-DD.
Example:
{
"tool": "get_change_events",
"args": {
"customer_id": "2054139041",
"login_customer_id": "6050181535",
"start_date": "2026-06-01",
"end_date": "2026-06-15",
"resource_type": "CAMPAIGN",
"limit": 50
}
}Conversion insights
Use get_conversion_insights when you need conversion-only reporting by day or conversion action, for example "which campaigns had lead conversions each day last week."
It supports the same levels as get_insights:
campaignad_groupadcustomer(account-level metrics)account(alias ofcustomer)
Optional segmentation:
segment_by_datesegment_by_conversion_action
Optional conversion-action filters:
conversion_action_idconversion_action_name
Rules:
pass at most one of the two parameters
conversion_action_idmust be a Google Ads resource name such ascustomers/1234567890/conversionActions/555conversion_action_namematchessegments.conversion_action_nameget_conversion_insightsreturns onlymetrics.conversionsandmetrics.conversions_value
Use get_insights for general performance metrics such as impressions, clicks, CTR, CPC, and cost. Use get_conversion_insights for conversion-action or daily conversion breakdowns.
Requirements
Python 3.10+
Node.js v25.8.1+ (only for MCP Inspector testing)
Google Ads API credentials:
GOOGLE_ADS_DEVELOPER_TOKENGOOGLE_ADS_CLIENT_IDGOOGLE_ADS_CLIENT_SECRET
Optional:
GOOGLE_ADS_REFRESH_TOKEN(backwards-compatible override; normally generated with MCP auth tools)GOOGLE_ADS_AUTH_FILE(defaults to~/.config/flin-google-ads-mcp/auth.json)GOOGLE_ADS_OAUTH_REDIRECT_URI(defaults tohttp://127.0.0.1:8080/)GOOGLE_ADS_LOGIN_CUSTOMER_IDGOOGLE_ADS_CUSTOMER_ID(default customer if nocustomer_idargument is passed)GOOGLE_ADS_USE_PROTO_PLUS(trueby default)
For MCC flows, you can also pass login_customer_id directly per tool call.
Auth flow
The MCP client config no longer needs GOOGLE_ADS_REFRESH_TOKEN.
Configure
GOOGLE_ADS_DEVELOPER_TOKEN,GOOGLE_ADS_CLIENT_ID, andGOOGLE_ADS_CLIENT_SECRET.Run
auth_status.If it reports
missing_refresh_token, runget_auth_url.Open the returned Google URL, sign in, and copy either the
codevalue or the full redirected URL.Run
save_refresh_token_from_codewith that value.Run
health_check.
The stored refresh token is written to ~/.config/flin-google-ads-mcp/auth.json by default and is never returned by MCP tools.
Quick flow: "Avesco spend yesterday"
Find the subaccount by name under the manager:
{
"tool": "find_customer_clients",
"args": {
"manager_customer_id": "6050181535",
"login_customer_id": "6050181535",
"name_query": "Avesco",
"direct_only": false,
"include_hidden": false,
"include_self": false,
"status": "ALL",
"limit": 50
}
}Use the returned
client_customer_idwith account-level insights:
{
"tool": "get_insights",
"args": {
"customer_id": "2054139041",
"login_customer_id": "6050181535",
"level": "account",
"date_range": "YESTERDAY",
"limit": 10
}
}Date ranges
get_insights, get_conversion_insights, get_keywords, and get_search_terms support:
TODAYYESTERDAYTHIS_WEEK_MON_TODAYTHIS_WEEK_SUN_TODAYLAST_WEEK_MON_SUNLAST_WEEK_SUN_SATLAST_7_DAYSLAST_14_DAYSLAST_30_DAYSLAST_60_DAYSLAST_90_DAYSTHIS_MONTHLAST_MONTHCUSTOM(requiresstart_dateandend_dateinYYYY-MM-DD)
Quickstart (from source)
uv sync --extra dev
cp .env.example .env
# Fill .env values
uv run flin-google-ads-mcpQuickstart (as published package)
uvx flin-google-ads-mcp@latestClaude integration (published via uvx)
{
"mcpServers": {
"flin-google-ads-mcp": {
"command": "uvx",
"args": ["flin-google-ads-mcp@latest"],
"env": {
"GOOGLE_ADS_DEVELOPER_TOKEN": "xxx",
"GOOGLE_ADS_CLIENT_ID": "xxx",
"GOOGLE_ADS_CLIENT_SECRET": "xxx",
"GOOGLE_ADS_CUSTOMER_ID": "1234567890",
"GOOGLE_ADS_LOGIN_CUSTOMER_ID": "1234567890"
}
}
}
}Claude integration (local development)
{
"mcpServers": {
"flin-google-ads-mcp-local": {
"command": "uv",
"args": [
"run",
"--directory",
"/Users/nicolasg/Antigravity/flin-google-ads-mcp",
"flin-google-ads-mcp"
],
"env": {
"GOOGLE_ADS_DEVELOPER_TOKEN": "xxx",
"GOOGLE_ADS_CLIENT_ID": "xxx",
"GOOGLE_ADS_CLIENT_SECRET": "xxx",
"GOOGLE_ADS_CUSTOMER_ID": "1234567890",
"GOOGLE_ADS_LOGIN_CUSTOMER_ID": "0987654321"
}
}
}
}How to test
Detailed guide: docs/testing.md
Release checklist: docs/release.md
Operational usage guide:
Fast path:
uv sync --extra dev
python3 -m pytest
python3 -m compileall srcThen run live smoke tests with MCP Inspector (see the testing guide).
Release on GitHub + PyPI
This repository publishes automatically with GitHub Actions:
CI:
.github/workflows/ci.ymlRelease:
.github/workflows/release.yml(triggered by git tagsv*)
1) Configure PyPI Trusted Publisher (one-time)
In PyPI project settings for flin-google-ads-mcp, add a Trusted Publisher with:
Owner:
flin-agencyRepository:
flin-google-ads-mcpWorkflow:
release.ymlEnvironment:
pypi
2) Cut a release
# bump version in pyproject.toml first, then:
git add -A
git commit -m "release: v0.1.0"
git tag v0.1.0
git push origin main --tagsThe Release workflow builds, tests, and publishes to PyPI using OIDC (no PyPI API token in GitHub secrets).
CI
GitHub Actions validates:
unit tests
import/compile checks
package build
Available Tools
9 toolsfind_customer_clientsC
Find subaccounts by descriptive name under a specific manager account.
| Name | Required | Description | Default |
|---|---|---|---|
| manager_customer_id | Yes | ||
| name_query | Yes | ||
| status | No | ALL | |
| direct_only | No | ||
| include_hidden | No | ||
| include_self | No | ||
| limit | No | ||
| login_customer_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description only says 'Find', implying a read operation, but does not disclose any behavioral traits such as authentication requirements, rate limits, or side effects.
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?
Single sentence of 9 words is concise and front-loaded. However, brevity sacrifices crucial detail.
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?
With 8 parameters, no annotations, and an output schema present, the description provides minimal context. It does not explain the purpose of most parameters or the nature of the output.
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 0%. Description only hints at 'manager account' and 'descriptive name', covering 2 of 8 parameters. Leaves 6 parameters unexplained, forcing reliance on schema property names.
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?
Description clearly states 'find subaccounts by descriptive name under a specific manager account', giving a specific verb and resource. It distinguishes from sibling tool 'get_customer_clients' by implying a search/filter 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?
No guidance on when to use this tool versus alternatives like 'get_customer_clients'. No mention of prerequisites or context for invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_ad_groupsC
Get ad groups for a customer account, optionally filtered by campaign.
| Name | Required | Description | Default |
|---|---|---|---|
| customer_id | No | ||
| campaign_id | No | ||
| status | No | ALL | |
| limit | No | ||
| login_customer_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose all behavioral traits. It only mentions data retrieval with optional filtering, lacking details on side effects, permissions, rate limits, or output behavior.
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, but it sacrifices completeness. While front-loaded, it does not fully utilize the space to add value for the agent.
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?
Despite an output schema existing, the description fails to explain the tool's behavior sufficiently for 5 parameters. Missing parameter guidance and usage context make it inadequate for correct invocation.
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 0%, and the description only hints at campaign_id filtering. It does not explain the other four parameters (customer_id, login_customer_id, status, limit), leaving the agent with minimal information beyond basic schema names.
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 retrieves 'ad groups' for a 'customer account', with optional filtering by campaign. It uses a specific verb and resource, differentiating it from sibling tools like get_ads or get_campaigns.
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 on when to use this tool versus alternatives. The description simply states what it does without providing context on preferred scenarios or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_adsB
Get ads for a customer account, optionally filtered by campaign or ad group.
| Name | Required | Description | Default |
|---|---|---|---|
| customer_id | No | ||
| campaign_id | No | ||
| ad_group_id | No | ||
| status | No | ALL | |
| limit | No | ||
| login_customer_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must cover behavioral traits. Only states 'Get ads' (read operation), but does not disclose pagination, rate limits, authentication needs, or response structure. Lacks depth for a safe agent invocation.
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?
Single sentence, 12 words, front-loaded with action verb. 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?
Tool has 6 parameters with no required ones, plus output schema; description lacks details on status, limit, login_customer_id, and authentication context. Incomplete for effective use despite conciseness.
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 0%; description only explains campaign_id and ad_group_id filters. No explanation for customer_id, status, limit, or login_customer_id. Status default 'ALL' is undefined. Minimal value added beyond 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 verb 'get', resource 'ads', and scope 'for a customer account', with optional filters. It distinguishes from sibling tools like get_ad_groups and get_campaigns.
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 on when to use this tool vs alternatives (e.g., get_ad_groups, get_campaigns). It mentions optional filters but doesn't provide context for when to use specific parameters or exclude others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_campaignsC
Get campaigns for a customer account.
| Name | Required | Description | Default |
|---|---|---|---|
| customer_id | No | ||
| status | No | ALL | |
| limit | No | ||
| login_customer_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, authentication needs, or rate limits. It only states a generic fetch action.
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, which is concise, but it lacks structure. It is not overly long, but for a 4-parameter tool, it is too minimal to be effective.
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?
Given the tool has 4 parameters and an output schema, the description fails to explain what campaigns are, how filtering works, or what the output contains. It is incomplete for effective agent use.
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?
With 0% schema description coverage and no mention of parameters in the description, the agent gains no insight into the meaning of customer_id, status, limit, or login_customer_id beyond their names and types.
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 'Get campaigns for a customer account,' indicating the action and resource. However, it does not differentiate from sibling tools like get_ad_groups or get_ads, lacking specificity.
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 on when to use this tool versus alternatives. The description provides no context for when to use it over siblings like find_customer_clients or get_insights.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_customer_clientsC
List subaccounts under a manager account using the customer_client resource.
| Name | Required | Description | Default |
|---|---|---|---|
| customer_id | No | ||
| status | No | ALL | |
| direct_only | No | ||
| include_hidden | No | ||
| include_self | No | ||
| limit | No | ||
| login_customer_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states it 'lists subaccounts'. It fails to disclose important behaviors such as default parameter values, pagination via 'limit', filtering options (status, direct_only, include_hidden, include_self), or any side effects. The agent lacks crucial operational details.
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, which is concise, but it sacrifices necessary detail. It could include more context without being verbose, especially given the 7-parameter schema and sibling tools. It is not front-loaded with critical 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?
Given the tool has 7 parameters and no parameter descriptions in the schema, the description is insufficiently complete. While an output schema exists, the lack of parameter explanations and behavioral cues means the agent cannot effectively use the tool without external knowledge. The description needs to cover the role of key 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 0%, yet the description adds no explanation for any of the 7 parameters. Parameters like 'customer_id', 'status', 'direct_only', etc., are not mentioned, leaving their semantics entirely unclear. The tool name and description do not even hint at the filtering capabilities.
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 ('List subaccounts') and the resource ('customer_client') with a specific context ('under a manager account'). It differentiates from the sibling 'find_customer_clients' by implying a straightforward listing rather than a search.
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 guidance on when to use this tool versus its sibling 'find_customer_clients' or other tools. It does not mention prerequisites, limitations, or context for use, leaving the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_insightsB
Get read-only performance metrics for campaign, ad_group, or ad level.
| Name | Required | Description | Default |
|---|---|---|---|
| customer_id | No | ||
| level | No | campaign | |
| date_range | No | LAST_30_DAYS | |
| start_date | No | ||
| end_date | No | ||
| limit | No | ||
| login_customer_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes the tool as read-only, indicating no side effects, but lacks details on auth needs, rate limits, or pagination behavior.
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, but could be slightly expanded to include parameter guidance without losing efficiency.
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 tool with 7 parameters and no schema descriptions, the description is too brief, omitting details about metric types, time range usage, and output interpretation.
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?
With 0% schema description coverage, the description only partially explains the 'level' parameter, leaving most parameters (customer_id, date_range, etc.) undocumented.
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 it retrieves read-only performance metrics at campaign, ad_group, or ad level, distinguishing it from sibling tools that fetch entity lists.
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 implies usage for performance data but does not explicitly state when not to use it or provide alternatives among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywordsC
Get keyword-level entities and performance metrics.
| Name | Required | Description | Default |
|---|---|---|---|
| customer_id | No | ||
| campaign_id | No | ||
| ad_group_id | No | ||
| status | No | ALL | |
| date_range | No | LAST_30_DAYS | |
| start_date | No | ||
| end_date | No | ||
| limit | No | ||
| login_customer_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must carry full burden. It only states 'Get' implying read-only, but doesn't disclose pagination behavior, filtering capabilities, or any potential side effects. Missing details on what 'performance metrics' are included.
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?
Single sentence, front-loaded, but overly terse. While concise, it sacrifices necessary detail for a tool with 9 parameters and no schema descriptions.
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?
With 9 parameters and an output schema, the description does not explain what the tool returns or how filtering works. It is insufficient for an agent to correctly invoke without additional context.
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 has 9 parameters with 0% description coverage. The description adds no explanation for parameters like customer_id, campaign_id, date_range, etc., relying entirely on the schema which lacks descriptions.
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 retrieves 'keyword-level entities and performance metrics', specifying the resource (keywords) and data type (performance metrics). It differentiates from siblings like 'get_ad_groups' or 'get_ads' by focusing on keywords.
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 on when to use this tool versus alternatives. The description lacks context for selecting it among siblings like 'get_insights' or 'get_campaigns'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
health_checkA
Check whether required Google Ads configuration is present and client initialization works.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description only states 'check' without disclosing outcomes, side effects, or error conditions. Lacks behavioral detail for a zero-param 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?
Single sentence, front-loaded, no unnecessary words. Efficiently conveys purpose.
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?
Given zero params and presence of output schema, the description is mostly complete. However, behavioral details are missing, slightly reducing 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?
No parameters exist, so schema coverage is 100%. Description adds no param info, but baseline for 0 params is 4.
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 ('check') and identifies the resource ('Google Ads configuration' and 'client initialization'). It clearly distinguishes from sibling tools that retrieve 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 implies usage as a preliminary check but does not explicitly state when to use or alternatives. Implied context from siblings but no direct guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_accessible_customersB
List customer IDs accessible by the configured OAuth credentials.
Google Ads API ignores login_customer_id for this specific operation.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| login_customer_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries the burden. It discloses that login_customer_id is ignored, which is helpful. However, it does not state if the operation is read-only, safe, or any potential side effects. The output schema exists, so return format is covered externally.
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?
Two concise sentences with no fluff. The first sentence defines purpose immediately; the second adds a key behavioral note. Could be slightly improved by more front-loading, but it is effective.
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?
With an output schema, return values are covered. However, the description omits explanation for the limit parameter, which is essential for controlling result size. The behavioral note is useful, but overall completeness is average.
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 0%, so description should explain parameters. Only login_customer_id is mentioned (as ignored). The limit parameter, though optional with a default, is not described at all, leaving the agent without guidance on its purpose.
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 lists customer IDs accessible by OAuth credentials. The verb 'List' and resource 'customer IDs' are specific. However, it does not differentiate from siblings like find_customer_clients or get_customer_clients, which might serve similar 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?
No guidance on when to use this tool versus alternatives. The note about login_customer_id being ignored is a behavioral detail, not usage context. Sibling tools exist but no comparison is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool targets a distinct resource or action: searching vs listing customers, retrieving specific entities (campaigns, ad groups, ads, keywords), performance insights, health check, and account listing. No significant overlap.
Tools predominantly use verb_noun snake_case (e.g., get_campaigns, list_accessible_customers). 'health_check' deviates slightly but remains clear and conventional.
9 tools is well-scoped for a Google Ads MCP, covering essential read operations and utility functions without overwhelming or under-serving the domain.
The tool set provides thorough read-only coverage of core Google Ads entities (campaigns, ad groups, ads, keywords, insights) and account management. Missing write operations, but the server appears focused on querying.
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
Google Ads MCP server — manage campaigns, keywords, and metrics.
Read-only MCP server for AIStatusDashboard status, incidents, metrics, and fallback recommendations.
Read-only MCP access to your DEXUN AdWhiz account: ad accounts, AI recommendations, savings.
MCP server for querying and analyzing data from ad platforms, analytics tools, and spreadsheets
Related MCP Servers
- AlicenseBqualityBmaintenanceRead-only MCP server for Meta Ads that lists and reads ad accounts, campaigns, ad sets, ads, ad images, creatives, and fetches insights at various levels.14MIT
- AlicenseNot gradedqualityCmaintenanceProvides read-only access to Google Ads account data including campaigns, ad groups, keywords, and performance reports. Enables querying via GAQL through an MCP interface.MIT
- AlicenseAqualityBmaintenanceA read-only MCP server for querying Google Ads data using GAQL, enabling AI assistants to safely read campaign performance, ad groups, and keywords.12MIT
- AlicenseBqualityCmaintenanceRead-only MCP server for Google Ads API, enabling natural language queries about campaigns, metrics, search terms, and change history without write access.6MIT
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/flin-agency/flin-google-ads-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server