Google Ads

Live

OAUTH 2.0

ADVERTISING

Marketing

Every campaign, ad group, and performance metric your team manages lives in Google Ads. Google Ads MCP gives your agent authenticated access to ad data scoped to the user who authorized it.

  • Acts as the user: Access and write actions stay tied to the Google Ads account that authorized the agent.
  • Credentials stay vaulted: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: User permissions enforced. 90-day audit trail.
Google Ads
agent · Acme Q3
Run
Which campaigns have CPC above $5 and conversion rate below 2% this month?
S
googleads_metrics_get
96ms
Ads management agent
3 campaigns underperforming. Brand Awareness ($6.20 CPC, 1.4% CVR), Retargeting-EU ($5.80 CPC, 1.8% CVR), Competitor Keywords ($7.10 CPC, 0.9% CVR). Recommend budget reallocation.
Sources: 3 campaigns, this month
googleadsmcp
3 campaigns
18:29
Message Claude...

Tools your ads management agent reaches for on Google Ads, scoped per user.

CALL ANY TOOL
List campaigns and ad groups, pull performance metrics, manage keywords, and update budgets.
googleads_search
Search
Execute a GAQL (Google Ads Query Language) query to retrieve campaigns, ad groups, keywords, metrics, and any other Google Ads data. Returns paginated results.
Parameters
Name
Type
Required
Description
customer_id
string
Required
Google Ads customer account ID (without hyphens), visible in the top-right of the Google Ads UI.
developer_token
string
Required
Google Ads API developer token required for all API calls. Obtain from your Google Ads API Center.
query
string
Required
GAQL query string to execute. Use SELECT, FROM, WHERE, ORDER BY, and LIMIT clauses. Example: SELECT campaign.id, campaign.name, campaign.status FROM campaign WHERE campaign.status != 'REMOVED' LIMIT 50
login_customer_id
string
Optional
Manager account customer ID when accessing via a Google Ads manager (MCC) account. Omit if accessing a standalone account directly.
page_size
integer
Optional
Number of results to return per page. Maximum is 10000. Defaults to 10000 if not specified.
page_token
string
Optional
Token for retrieving the next page of results. Obtained from the nextPageToken field of a previous response.
schema_version
string
Optional
Optional schema version to use for tool execution
tool_version
string
Optional
Optional tool version to use for execution
googleads_ad_remove
Ad remove
googleads_ad_update
Ad update
googleads_asset_create
Asset create
googleads_campaign_get
Campaign get
googleads_label_create
Label create
googleads_customer_get
Customer get
googleads_budget_create
Budget create
googleads_budget_remove
Budget remove
googleads_budget_update
Budget update
googleads_customers_list
Customers list
googleads_keyword_create
Keyword create
googleads_keyword_remove
Keyword remove
googleads_keyword_update
Keyword update
googleads_campaign_create
Campaign create
googleads_campaign_remove
Campaign remove
googleads_campaign_update
Campaign update
googleads_ad_group_get
Ad group get
googleads_ad_group_create
Ad group create
googleads_ad_group_remove
Ad group remove
googleads_ad_group_update
Ad group update
googleads_user_list_create
User list create
googleads_user_list_update
User list update
googleads_campaign_budget_get
Campaign budget get
googleads_campaign_label_create
Campaign label create
googleads_keyword_ideas_generate
Keyword ideas generate
googleads_bidding_strategy_create
Bidding strategy create
googleads_bidding_strategy_update
Bidding strategy update
googleads_conversion_action_create
Conversion action create
googleads_conversion_action_update
Conversion action update
Build your Agent
Drop the toolkit in, point it at the user, and your ads management agent can use Google Ads from the first run.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { DynamicStructuredTool } from "@langchain/core/tools";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { z } from "zod";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["googleads"], toolNames: ["googleads_campaigns_list", "googleads_campaign_get", "googleads_ad_groups_list"] },
pageSize: 100,
});

const lcTools = tools.map((t) => new DynamicStructuredTool({
name: t.tool.definition.name,
description: t.tool.definition.description,
schema: z.object({}).passthrough(),
func: async (args) => {
const { data } = await sk.tools.executeTool({
toolName: t.tool.definition.name,
identifier: "user_123",
params: args,
});
return JSON.stringify(data);
},
}));

const agent = createReactAgent({ llm, tools: lcTools });
import { ScalekitClient } from "@scalekit-sdk/node";
import OpenAI from "openai";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["googleads"], toolNames: ["googleads_campaigns_list", "googleads_campaign_get", "googleads_ad_groups_list"] },
pageSize: 100,
});

const llmTools = tools.map((t) => ({
type: "function",
function: {
name: t.tool.definition.name,
description: t.tool.definition.description,
parameters: t.tool.definition.input_schema,
},
}));

const resp = await openai.responses.create({
model: "gpt-4o", input: prompt, tools: llmTools,
});
import { ScalekitClient } from "@scalekit-sdk/node";
import Anthropic from "@anthropic-ai/sdk";

const sk = new ScalekitClient(envUrl, clientId, clientSecret);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
filter: { connectionNames: ["googleads"], toolNames: ["googleads_campaigns_list", "googleads_campaign_get", "googleads_ad_groups_list"] },
pageSize: 100,
});

const llmTools = tools.map((t) => ({
name: t.tool.definition.name,
description: t.tool.definition.description,
input_schema: t.tool.definition.input_schema,
}));

const msg = await anthropic.messages.create({
model: "claude-sonnet-4-6", max_tokens: 1024,
tools: llmTools,
messages: [{ role: "user", content: prompt }],
});
import { Agent } from "@google/adk/agents";
import {
MCPToolset, StreamableHTTPConnectionParams,
} from "@google/adk/tools/mcp";

const toolset = new MCPToolset({
connectionParams: new StreamableHTTPConnectionParams({
url: "https://mcp.scalekit.com/googleads",
headers: { Authorization: `Bearer ${userScopedToken}` },
}),
});

const agent = new Agent({
name: "agent", model: "gemini-2.0-flash",
tools: await toolset.getTools(),
});
Try these prompts
Paste any prompt into your agent to start using Google Ads.
Search & metrics
Copy the prompt
Copied
List all active campaigns.
Copy the prompt
Copied
Get performance metrics for [campaign] last 30 days.
Copy the prompt
Copied
Which ad groups have the highest CPC?
Copy the prompt
Copied
Show me all paused campaigns.
Action & updates
Copy the prompt
Copied
Update the daily budget for [campaign] to [$amount].
Copy the prompt
Copied
Pause campaign [name].
Copy the prompt
Copied
List keywords in [ad group].
Copy the prompt
Copied
Enable ad group [name] in [campaign].
Reporting & optimization
Copy the prompt
Copied
Which campaigns have conversion rate below 2%?
Copy the prompt
Copied
Compare CPC across all campaigns this month.
Copy the prompt
Copied
List campaigns with budget utilization above 90%.
Copy the prompt
Copied
Top 5 keywords by click volume.
SEE HOW AUTH WORKS
Users authorize Google Ads once. Their credentials stay vaulted, every call is checked, and every action is logged.
1
Authorize
Your user connects
Google Ads
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
Google Ads
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
Google Ads
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
Google Ads
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
Same per-user auth pattern across other ads management agents and MCP connectors. Working code, live demos, fork what fits.
GTM and RevOps Teams
Outbound prospecting agent
Searches Apollo for prospects matching your ICP, scores and ranks them, drafts personalized outreach in Gmail, and logs every send to Google Sheets. Mail goes out as the rep, not from a shared inbox.
GTM and RevOps Teams
CRM AI agent
Reads the Granola transcript after every call, extracts next steps and updates the HubSpot record, drafts the follow-up in Gmail, and confirms in Slack, all on the rep's own delegated OAuth.
GTM and RevOps Teams
Deal intelligence agent
Pulls recent Gong calls, scores deal risk with an LLM, cross-references the record in Attio, and DMs each owner their at-risk deals in Slack. Every read is scoped to that rep's own access.
GTM and RevOps Teams
Competitive intelligence briefing agent
Scans Gong calls for competitor mentions, matches each one to its Notion battlecard, and DMs every affected rep a single Slack digest per cycle. Every call runs as the PMM who owns the briefing, never a shared bot.
Test other agents
Same per-user auth pattern across other ads management agents and MCP connectors. Working code, live demos, fork what fits.
SALES
Outbound prospecting agent
Search Apollo for ICP matches, rank them, draft personalised Gmail outreach, and log every send to Google Sheets.
GTM
CRM AI agent
Turn each Granola call transcript into a HubSpot record update, a drafted Gmail follow-up, and a Slack recap.
SALES
Deal intelligence agent
Score Gong call risk with an LLM, cross-reference the Attio record, and DM each owner their at-risk deals in Slack.
GTM
Competitive intelligence briefing agent
Scan Gong calls for competitor mentions, match each one to its Notion battlecard, and DM every affected rep a single Slack digest.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
01.
Shared tokens break per-user analytics
A shared token looks fine in a demo. In production every call looks like a service account. Scalekit resolves the real user credential so attribution, audit, and scope stay accurate.
// shared token
 audit → bot_service_account
 user_filter → broken

 // scalekit
 audit → user_abc
 scope → enforced ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
Google Ads today. Others tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions
Does the agent access Google Ads as the user or as a shared key?
As the user. Each workspace member authorizes once and Scalekit resolves their credential at request time. Audit logs attribute every action to that user, not a shared service account.
Where is the Google Ads oauth 2.0 stored?
In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Tokens never appear in prompts, logs, or LLM context.
Can I limit what the agent is allowed to do in Google Ads?
Yes. Pass a tool name filter to listScopedTools so the ads management agent only sees the subset you authorize. Pre-API-call scope checks block out-of-policy actions before the request reaches Google Ads.
What happens when a user revokes Google Ads access?
The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.
Can the agent access accounts under a linked manager (MCC) account?
Only accounts the authorizing user has explicit access to. MCC child accounts require the user to have been granted account-level access before the agent can reach them.
Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""googleads"": {
""url"": ""https://mcp.scalekit.com/googleads"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.googleads]
url = ""https://mcp.scalekit.com/googleads""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""googleads"": {
""url"": ""https://mcp.scalekit.com/googleads"",
""type"": ""http""
}
}
}