# How to Connect Google Ads to Claude Using MCP

> A step-by-step guide to connecting Google Ads to Claude using MCP. Covers Developer Tokens, OAuth, refresh tokens, Claude Desktop config, and real prompts to use day one.

**By Murtaza Rangwala** · **Published:** May 18, 2026 · **Read time:** 10 min read · **Category:** Strategy

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.

!!!
**The TL;DR:** MCP is Anthropic's open standard for connecting Claude to external tools and data. A Google Ads MCP server bridges your Google Ads account into Claude using your Developer Token + OAuth credentials. Configure it once in Claude Desktop's config file, and Claude can query, analyse, and (carefully) act on your campaigns.
!!!

## What MCP actually is (in plain language)

MCP stands for **Model Context Protocol**. It's an open standard from Anthropic that lets Claude talk to external systems through small, purpose-built servers.

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](https://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.

!!!
**Important:** Test access only works against test Google Ads accounts. To run real reports on your live account, you need Basic access at minimum. Apply for Basic access as soon as possible after starting your application.
!!!

## Step 3: Create OAuth 2.0 credentials in Google Cloud Console

The MCP server needs OAuth credentials to authenticate.

1. Go to [Google Cloud Console](https://console.cloud.google.com).
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.
5. 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
   ```
2. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```
3. Run the included OAuth helper script (the exact filename varies by repo — check the README):
   ```bash
   python generate_refresh_token.py
   ```
4. A browser window opens. Sign in with the Google account that has access to your Google Ads accounts. Approve the scope.
5. 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](https://developers.google.com/oauthplayground) — 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](https://modelcontextprotocol.io)
- [Anthropic MCP introduction](https://docs.anthropic.com/en/docs/build-with-claude/mcp)
- [Google Ads API: Get started](https://developers.google.com/google-ads/api/docs/first-call/overview)
- [Google Ads API: Developer token application](https://developers.google.com/google-ads/api/docs/access-levels)
- [Google OAuth 2.0 Playground](https://developers.google.com/oauthplayground)
- [mcp-google-ads on GitHub (community server)](https://github.com/cohnen/mcp-google-ads)

---

**Tags:** google ads, automation, claude, MCP

## About the author

Murtaza Rangwala is a senior independent Google Ads consultant. 8 years, 1,900+ campaigns shipped, $250M+ in client revenue generated. Independent practice capped at four concurrent clients.

- More posts: https://www.murtazarangwala.com/blog
- Book a 30-min call: https://calendly.com/murtaza_rangwala/30min
- Free Google Ads audit: https://www.murtazarangwala.com/#audit