A Google Ads MCP app connects your ad account to an AI assistant like Claude, so you can read performance and make specific changes straight from the chat. Without a Google Ads MCP server in place, Claude has no way to see your spend, campaigns or keywords. This article covers what such an app can read, what it can write, how to set it up safely, and where to draw the line.
- Claude can't see your ad account until you connect a Google Ads MCP server - the app on the other end that exposes the Google Ads API as tools.
- Google's official open-source server (googleads/google-ads-mcp, Apache 2.0) is read-only; hosted apps like B77's add write actions on top of the same API.
- Reads don't modify the account; writes touch live budgets and ads and should be confirmed one at a time.
- Setup on Claude is three steps: install and authorize, add the connector, test with a read-only question.
- House rules: no bid-strategy or goal changes, keep writes to budgets/keywords/ads/status, audit weekly.
- The same pattern applies to an Apple Search Ads app.
What a Google Ads MCP app is (and why Claude can't see your account without one)
Think of B77 as the App Store for your AI assistant. Out of the box, Claude knows nothing about your ad account - it can't see your spend, your campaigns or your keywords. Install the Google Ads app and it reads the numbers for you and makes only the changes you ask for in the chat.
A few terms, once. MCP (Model Context Protocol) is the open standard that lets an AI assistant call external tools. An MCP server is the app on the other end. The client is the assistant - Claude, ChatGPT or Cursor. And the LLM is the model doing the reading and writing. A Google Ads MCP server exposes the Google Ads API to the assistant as tools that AI agents can discover and call.
As of 2026-09-01: Google publishes an official open-source Google Ads MCP server on GitHub (googleads/google-ads-mcp, Apache 2.0). Its README lists three query tools - search, get_resource_metadata and list_accessible_customers - and no mutate tool, and warns verbatim: "The MCP Server will expose your data to the Agent or LLM that you connect to it." B77's Google Ads app both reads and writes, and its app page states it "never acts on its own - every mutation is one you asked for in the chat."
Ahead: a read-vs-write table, a three-step setup, daily and weekly prompts, house rules, the Apple Search Ads twin, and an FAQ.
Read vs write: what a Google Ads MCP server can do
Most of what people want from a Google Ads MCP falls into two buckets: reading data to analyze performance, and writing changes to manage the account. Not every server does both. The table below compares the tools exposed by the official Google server against the B77 Google Ads app.
| Capability | Official Google server | B77 Google Ads app |
|---|---|---|
| Read - list accessible accounts | Yes | Yes |
| Campaign, ad group and keyword performance | Yes | Yes |
| Spend and conversions by date range | Yes | Yes |
| Search terms | Yes | Yes |
| Custom GAQL query as table, CSV or JSON | Yes | Yes |
| Write - adjust campaign budgets | No | Yes, on explicit chat instruction |
| Add or pause keywords | No | Yes, on explicit chat instruction |
| Add negative keywords | No | Yes, on explicit chat instruction |
| Create responsive search ads | No | Yes, on explicit chat instruction |
| Pause or enable campaigns | No | Yes, on explicit chat instruction |
The official server's three tools are query-only (checked 2026-09-01 in the repo README), so it can analyze but never change your account.
In plain English: reads go through GoogleAdsService.Search with a GAQL query. Writes go through mutate methods such as CampaignService.MutateCampaigns or the combined GoogleAdsService.Mutate - the same kinds of account changes you can make through the web interface, applied to the live account via the Google Ads API. Changes made through the API show up in the account's Change History. The current Google Ads API major version is v25, released 2026-07-22, with v25.1 following on 2026-08-19, per the official release notes.
The split matters. Reads don't modify the account, so they carry far less operational risk than writes - though what they return is shared with the LLM, and each query spends API quota. Writes touch live budgets and ads, so that is exactly where the house rules apply.
Setup: connect the Google Ads app to Claude in three steps
Step 1 - Install and authorize. On the app's B77 page, click Install and sign in with the Google account that has access to your ad account. This runs an OAuth 2.0 authorization flow - the protocol the Google Ads API uses for authorizing requests. The grant is stored encrypted and stays private to your B77 account. The app stores no campaign data: each request talks to the Google Ads API live. It's free, no card required. Expected result: the app shows as connected.
Step 2 - Add it as a connector. Copy the connection URL from the app page, open the connector settings, choose "Add custom connector", paste the URL and give it a name. Expected result: the Google Ads tools appear in Claude's tool list. Claude MCP connectors are how the assistant discovers and calls those tools. The same URL works as a connector in ChatGPT and as an MCP server in Cursor - the client is whichever assistant you use, so the flow on each platform mirrors these steps.
Step 3 - Test with a read-only question. Ask something like "List the accounts I can access and yesterday's spend per campaign." The reply should quote real campaign names. If it doesn't, check that you authorized the right Google account and that the connector shows as connected in your list of Claude connectors before you connect anything else.
A daily and weekly prompt set for Google Ads
Once you're connected, here are copy-pastable prompts you can drop into the chat. The daily set is all reads, so the app runs them automatically on request - no confirmation needed. This is where Google Ads AI tooling earns its keep: pulling numbers you would otherwise export by hand.
Daily prompts (reads, run automatically)
- "Show month-to-date spend against each campaign's budget pace." - Compares month-to-date cost with the monthly equivalent of each campaign's average daily budget (Google caps most campaigns at 30.4 times the daily budget per month).
- "List new search terms since yesterday that spent money without converting, as negative-keyword candidates." - Reads the search terms report and flags wasted spend.
- "Which ads were disapproved or limited today?" - Returns ad status changes from the last day.
- "Which campaigns had conversions drop versus the same weekday last week?" - Compares like-for-like days and surfaces the fallers.
Weekly prompts (mixed)
- "Show keyword winners and losers by cost per conversion this week."
- "List campaigns marked limited by budget."
- "Report responsive search ad asset performance."
- "Write a one-paragraph weekly digest for the team."
Write prompts (confirm before it acts)
Each of these is executed only after the app shows exactly what it will change and you confirm in the chat:
- "Add these search terms as negatives to Campaign X."
- "Raise Campaign X's daily budget by [stated amount]."
- "Pause the keyword [exact keyword] in Campaign X."
Phrase writes precisely: name the campaign, state the exact value, and identify the keyword in full. The app changes only what you name - vague wording leaves room for the wrong campaign to be touched. Reads can be loose and exploratory; writes should read like an instruction you would be comfortable signing off. That discipline is what makes AI for Google Ads management safe to run day to day.
House rules: what you shouldn't let the app do
A Google Ads MCP app can adjust real money-spending campaigns, so treat it like a junior team member: capable, but working under clear limits. These rules come from practice, and they keep a Claude Google Ads workflow useful without letting it do damage.
- Never change the bid strategy or goals of a campaign that is working. Per Google Ads Help ("Duration of the learning period," checked 2026-09-01), a change to a bid strategy setting puts it back into "Learning," and it "can take up to 3 weeks or 1-2 conversion cycles for the bid strategy to calibrate to the new objective." A working campaign should not be reset for a small tweak.
- Send experiments to a new campaign or to Google Ads' own custom experiments. Custom experiments split traffic between the original and a trial, and let you apply the change only if it wins - so you test safely instead of gambling on the live campaign.
- One write at a time. Ask for a preview, read the list of changes, then confirm. Avoid bulk pause or delete prompts; a single mistaken instruction can cascade across an account.
- Keep the app's writes to the four families its permissions cover - budgets, keywords, ads and campaign status. Manage everything structural (conversion goals, bidding, targeting) by hand, as a deliberate manual decision.
- Audit weekly. The Google Ads API's change_event resource can show the user email, client type (API or web client), time, and old and new values for supported changes from the past 30 days, so the app's edits sit visibly next to human ones - though it may not include every row of the web Change History.
- Do not run write prompts against a client's account without the client's sign-off in writing. When you manage spend on someone else's behalf, explicit consent protects both sides.
The pattern is simple: let the app adjust the day-to-day, and reserve every structural change for a manual hand on the wheel.
Security: scopes, tokens and what the LLM sees
OAuth 2.0 is the authorization framework under which you sign in with Google and grant the app a scoped token, so it acts on your behalf without ever seeing your password. PKCE (Proof Key for Code Exchange) is a check that ties the token exchange to the same client that started the sign-in, so an intercepted code can't be redeemed by anyone else.
Per the B77 Google Ads app page, the app can see your Google Ads campaigns, keywords and performance metrics. Its write access is limited to budgets, keywords, ads and campaign status. It never sees your other apps, files or accounts you didn't connect. Nothing is stored - each request talks to the Google Ads API live - and your credentials are encrypted and private to your user, defined by the scopes you grant.
Now the honest part, straight from Google's own README for the official server: whatever a tool returns is handed to the LLM. So the report you ask for ends up in the chat. Treat the conversation as containing account data. Don't paste developer tokens or client secrets into prompts, and don't share the chat thread outside the team that may see the account or its log.
To cut the app off completely: remove the connector in your assistant, then revoke the app's access in your Google account settings. Doing both invalidates the tokens and ends any further access.
Self-hosted server or hosted app?
There are two honest ways to get a Google Ads MCP server in front of your assistant, and they suit different people. One is Google's open-source server, which you run yourself; the other is one of the hosted MCP servers you connect in the browser. Here's how they compare.
| Self-hosted (Google's open-source server) | Hosted app (B77 platform) | |
|---|---|---|
| Who runs it | You do - install from GitHub, start it with pipx on your own machine or server | B77 operates the server for you |
| Credentials you need | Per its README: Google Ads API credentials - a Google Cloud project with OAuth credentials or Application Default Credentials, or an existing google-ads.yaml - plus a developer token | Sign in with Google in the browser; no developer token or Cloud setup on your side |
| Read/write | Read-only | Read and write, with confirmation |
| Clients | Claude Code, Cursor, VS Code and any MCP client over stdio or SSE/HTTP | Claude, ChatGPT and Cursor |
| Cost | Free software; you operate it | Free |
Self-hosting is the right call for an engineering team that wants its own audit trail and network controls, and is comfortable managing OAuth credentials and a developer token. If that's you, the open-source project is a solid base and you keep every byte on infrastructure you control.
A hosted app fits a marketer or founder who wants to ask questions today, not next sprint. A hosted app skips the Cloud project setup entirely: you sign in and start querying. If you're wiring up a Google Ads MCP server Claude can use without touching a terminal, browse the B77 catalog and connect one in a couple of clicks.
The Apple Search Ads twin
The same pattern works for Apple Search Ads, the platform that promotes apps in App Store search results. B77's Apple Search Ads MCP app connects an Apple Ads account the same way you connect Google Ads: one OAuth sign-in, credentials encrypted per user, no campaign data stored.
On the read side, the app can list your organizations and campaigns; pull reports by campaign, ad group, keyword, search term, geo and device; show spend and install data; and pace spend against a monthly target you set.
On the write side - only ever on an explicit request - it can create campaigns and ad groups, add and re-bid keywords, pause keywords, add negative keywords at campaign or ad-group level, promote search terms to exact-match keywords, clone campaigns to new countries, and adjust bids and budgets.
The same house rules apply, with one twist. For App Store search, promote-to-exact-match is the prompt people reach for most: a search term that converts becomes its own exact-match keyword. Because it changes campaign structure, ask the app to list the candidates first, review them, then confirm the ones you actually want.
Frequently asked questions
Is there an MCP for Google Ads?
Yes. As of 2026-09-01 there is Google's own open-source, read-only server on GitHub, plus hosted apps such as B77's that add write actions on top of the same API. The read-only option is enough for reporting and diagnosis; a hosted app is what you want if you need to make changes from the chat.
Does Google have an official MCP?
Yes. The googleads/google-ads-mcp repository on GitHub is Google's official server, released under the Apache 2.0 license. It exposes query tools only - it can pull reports and diagnose issues, but it cannot create campaigns, change bids or edit keywords.
Can Claude change my bids or budgets on its own?
No. The B77 app executes a mutation only when you ask for it directly in the chat, and the house rules above keep bidding out of the app's hands entirely. Claude cannot act while you are away, and it cannot touch anything you haven't explicitly requested.
Is $20 a day good for Google Ads?
It depends on your cost per click and conversion rate, so there is no honest single answer. Instead of guessing, ask the app for your own account's average cost per click and conversions over the last month, then do the arithmetic from your real numbers. A budget that works for one account can be far too low or too high for another.
Is the Google Ads MCP app free?
On B77, yes - the app is free and no card is required, so Google Ads MCP pricing is not a barrier to trying it. You still pay Google for the ads themselves, exactly as you do today.
Conclusion
A Google Ads MCP app turns your assistant into a fast, honest reporting layer over the account - and, when you ask precisely, a careful hand for day-to-day edits. Keep reads free-flowing, keep writes deliberate, and reserve every structural change for a manual decision. When you're ready to skip the Cloud project work and connect one to Claude, ChatGPT or Cursor in a couple of clicks, browse the B77 marketplace and install the Google Ads app - it's free to try, and useful from your first read-only question.Browse hosted MCP servers and connect one to your assistant in a couple of clicks: the B77 marketplace.
