How to Connect Google Ads to Claude Using MCP

If you run Google Ads at any scale, you already know the daily grind: pulling reports, eyeballing search terms, checking negative keyword lists, comparing yesterday's spend against the rolling 30-day average. Hours every week, mostly spent in dropdowns.

Most of it can be handed off to Claude through MCP (Model Context Protocol). Once it's wired up, you can ask Claude things like "summarise yesterday's performance across all my accounts and flag anything off-baseline" and get a real answer that reads your actual Google Ads data. Not a hallucination. Not a generic template. Your numbers.

The setup is a one-time job. After that, it just works.

Here's the full walkthrough.

What MCP actually is (in plain language)

Think of it as a USB-C port for AI: instead of every tool needing a custom integration, MCP gives them a shared connector. Google Ads, Slack, your file system, your database — all of them can be exposed to Claude through their own MCP server.

For Google Ads, an MCP server takes your API credentials and exposes a set of operations (read reports, list campaigns, pull keyword performance, etc.) that Claude can call on your behalf.

You're not giving Claude your Google Ads password. You're giving an MCP server your OAuth refresh token, and Claude talks to that server.

What you'll be able to do once it's connected

• Daily standups in plain English. "Summarise yesterday's performance across accounts. Flag anything below baseline."
• Search term cleanup. "Pull the last 30 days of search terms with zero conversions and over £20 spend. Suggest negatives."
• Budget pacing checks. "Which campaigns are pacing more than 20% above their daily budget?"
• Performance comparisons. "Compare this month's CPA against last month's, by campaign."
• Bulk audits. "Find every campaign with broad match keywords, no negative keyword list, and a tROAS below 200%."
• Drafted changes. "Suggest negative keywords for Campaign X based on irrelevant search terms."

Anything Claude could do by hand if it could see the data — once MCP is connected, it can.

Prerequisites before you start

• A Google Ads account with API access.
• A Google Cloud Console project (free).
• Claude Desktop installed, or Claude Code, or Cowork mode.
• Python 3.10+ or Node.js 18+ depending on which MCP server you choose.
• A bit of comfort editing JSON config files. Not a deep technical skill, but you should be willing to open a .json file in a text editor.

Step 1: Pick your Google Ads MCP server

There are several open-source MCP servers for Google Ads. The most actively maintained, at time of writing:

• mcp-google-ads (Python, by cohnen on GitHub) — broad read coverage, easy local install.
• google-ads-mcp variants on the official MCP registry at modelcontextprotocol.io.
• Cowork's connector registry if you're using Cowork mode — searches and installs MCPs without leaving Claude.

For this guide I'll use mcp-google-ads as the example because it's the most documented one I've seen. The flow is similar for any of them.

Whichever server you pick, check its read-only vs read-write scope before you give it API credentials. Some servers can pause campaigns, change budgets, and create ads. Start with read-only until you trust the setup.

Step 2: Get a Google Ads Developer Token

This is the gatekeeper. Without it, no API access.

1. Sign in to your Google Ads Manager (MCC) account. If you don't have one, you'll need to create one — individual Google Ads accounts can't request developer tokens directly.
2. Click the tools icon, then under Setup, choose API Center.
3. Read and accept the API Terms and Conditions.
4. Fill out the developer token application form. Google will ask about your intended use case.
5. You'll receive a test access developer token immediately. Basic or Standard access requires a separate approval that can take days to weeks.

Step 3: Create OAuth 2.0 credentials in Google Cloud Console

1. Go to Google Cloud Console.
2. Create a new project (or reuse one).
3. Open APIs & Services > Library, search for Google Ads API, and click Enable.
4. Open APIs & Services > OAuth consent screen.

- User type: External (unless you're on Google Workspace and want Internal). - Fill in app name, support email, and developer contact. - Add the scope https://www.googleapis.com/auth/adwords. - Add yourself as a test user.

1. Open APIs & Services > Credentials.

- Click Create Credentials > OAuth client ID. - Application type: Desktop app. - Name it something memorable like Google Ads MCP. - Download the JSON file. You'll need the client_id and client_secret from it.

Step 4: Generate a refresh token

The refresh token is what lets the MCP server access your account long-term without needing you to log in every time.

The cleanest way:

1. Clone the MCP server repo locally:

``bash git clone https://github.com/cohnen/mcp-google-ads.git cd mcp-google-ads ``

1. Install dependencies:

``bash pip install -r requirements.txt ``

1. Run the included OAuth helper script (the exact filename varies by repo — check the README):

``bash python generate_refresh_token.py ``

1. A browser window opens. Sign in with the Google account that has access to your Google Ads accounts. Approve the scope.
2. The script prints a refresh token to your terminal. Copy it somewhere safe.

If your chosen MCP server doesn't include an OAuth helper, you can use Google's OAuth 2.0 Playground — set the scope to https://www.googleapis.com/auth/adwords and exchange the auth code for a refresh token manually.

Step 5: Find your Customer ID

In Google Ads, your Customer ID is the 10-digit number in the top-right corner when you're signed in (formatted like 123-456-7890).

• If you're using an MCC, you have an MCC Customer ID and individual account Customer IDs. The MCP server typically needs both — the MCC ID as login_customer_id and the account ID as customer_id.
• Strip the dashes when adding to config (e.g., 1234567890, not 123-456-7890).

Step 6: Configure Claude Desktop

Open Claude Desktop's config file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

If the file doesn't exist, create it. Add the Google Ads server to the mcpServers block:

``json { "mcpServers": { "google-ads": { "command": "python", "args": [ "/absolute/path/to/mcp-google-ads/server.py" ], "env": { "GOOGLE_ADS_DEVELOPER_TOKEN": "your_developer_token_here", "GOOGLE_ADS_CLIENT_ID": "your_oauth_client_id_here", "GOOGLE_ADS_CLIENT_SECRET": "your_oauth_client_secret_here", "GOOGLE_ADS_REFRESH_TOKEN": "your_refresh_token_here", "GOOGLE_ADS_LOGIN_CUSTOMER_ID": "1234567890", "GOOGLE_ADS_CUSTOMER_ID": "9876543210" } } } } ``

Replace each value with what you generated in the earlier steps. The command path needs to point at the actual Python (or Node) script for the MCP server you installed.

Save the file. Fully quit Claude Desktop (don't just close the window — use the menu's Quit option). Reopen it.

Step 7: Test the connection

In a new Claude conversation, ask:

"List the Google Ads campaigns in account 9876543210 with their status and budgets."

If the MCP server is wired up correctly, Claude will call the server, get the data, and respond with a real list.

If it doesn't work, the most common culprits are:

• Wrong path in the command or args (use absolute paths, not ~).
• Refresh token tied to a different Google account than the one with Ads access.
• Developer token still on Test access while you're querying a live account.
• Login Customer ID missing when querying through an MCC.
• Claude Desktop wasn't fully quit before reopening.

Check the MCP server's logs (usually written to a .log file in the install directory or printed to stderr). Most errors show up clearly there.

Step 8: Useful first prompts to try

Once it's working, start simple:

• "Show me the top 10 campaigns by spend in the last 7 days, sorted by ROAS."
• "Pull search terms from the last 14 days where cost is over £10 and conversions are zero. Group by campaign."
• "Which keywords have the highest impression share lost to budget?"
• "Find campaigns where the search impression share is below 50% AND CPA is below target. These are candidates for budget increases."
• "Compare Performance Max campaigns vs Search campaigns this month for ROAS, CPA, and conversions."

Don't ask Claude to make changes on day one. Let it read first. Watch how it interprets your data. Once you trust the read side, you can graduate to drafted-but-not-applied recommendations.

Use case: a 30-minute daily review compressed into 2 minutes

A composite based on patterns I've seen across multiple high-spend ad accounts.

Before MCP:

Every morning the same dance:

• Log into Google Ads.
• Pull yesterday's report across 8 campaigns.
• Export to a spreadsheet.
• Compare against a baseline tab.
• Note anomalies in a Notion doc.
• Slack the team a summary.

Total time: 30-45 minutes. Done five days a week. That's ~3 hours a week, ~150 hours a year on the same repetitive task.

After MCP:

A single morning prompt to Claude:

"Pull yesterday's performance for all enabled campaigns. Compare each campaign's CPC, CPA, ROAS, and conversion rate against its rolling 14-day average. Flag anything that moved more than 25% in either direction. Group by likely cause (budget pacing, auction pressure, conversion tracking lag). Output as a short Slack-ready summary."

Claude reads the live data, runs the comparisons, drafts the Slack message. The marketer reviews and posts.

Total time: 2-4 minutes including review.

What's interesting isn't just the time saved. It's that Claude catches things humans miss when they're skimming dashboards on autopilot — like a campaign whose CPC is normal but whose conversion rate dropped 40% (a likely tracking issue, not a performance issue).

Security considerations

A refresh token + developer token combo can pull every dollar of data from your ad account and, depending on the MCP server's scope, can also make changes. Treat it like a password.

• Store the refresh token in environment variables, not in plain text in a shared config repo.
• Never commit the config file with real credentials to GitHub. Add it to .gitignore.
• Use read-only MCP servers until you've audited the codebase. There's a real difference between a community server that can only call GoogleAdsService.search and one that can also call MutateCampaignsRequest.
• Restrict the OAuth client to just the adwords scope. Don't grant broader Google access than the MCP server needs.
• Rotate the refresh token if you suspect compromise. You can revoke it from your Google Account's security settings.

Common mistakes and how to avoid them

• Skipping the Basic Access application. Test tokens won't work against live accounts. Apply for Basic on day one.
• Wrong Customer ID format. Strip dashes. Use the MCC ID as login_customer_id only when you're querying child accounts.
• Letting Claude make changes you didn't review. Always read the diff before saying yes. Smart bidding adjustments and campaign pauses are reversible but visible.
• Using a personal Google account when the Ads account belongs to a Workspace. Use a service account or a Workspace user that has access.
• Forgetting to restart Claude Desktop. Config changes only load on full restart, not on window close.
• Pointing at the wrong Python interpreter. If you installed dependencies in a virtualenv, the command in the config needs to point at that virtualenv's Python binary, not the system one.

Bottom line

Connecting Google Ads to Claude through MCP isn't a magic productivity hack. It's just removing the part of the job that doesn't need a human:

• Pulling data → MCP server does it.
• Comparing it against baselines → Claude does it.
• Drafting the recommendation → Claude does it.
• Reviewing and deciding → you do it.

That last step is the one you should always own. Everything before it is glue work, and MCP is glue.

The setup is a one-time afternoon. The payoff compounds every morning after that.

---

Sources and further reading:

• Model Context Protocol documentation
• Anthropic MCP introduction
• Google Ads API: Get started
• Google Ads API: Developer token application
• Google OAuth 2.0 Playground
• mcp-google-ads on GitHub (community server)