How to Connect Google Ads to Claude Using MCP

You can now ask Claude questions about your Google Ads account in plain English — "Which campaigns have a CPA over £50 in the last 30 days?" — and get an answer pulled straight from the Google Ads API, no spreadsheet export required. The bridge that makes this possible is called MCP, and setting it up takes about half an hour. This guide walks you through every step, with the exact terminal commands for both Mac and Windows.

What is MCP, and why connect it to Google Ads?

MCP stands for the Model Context Protocol — an open standard, created by Anthropic (the company behind Claude), that lets Claude plug into outside tools and data sources. Think of it as a universal adapter: instead of copying data into a chat, you connect Claude to a small piece of software called an "MCP server" that knows how to talk to a specific service. A Google Ads MCP server is exactly that — a connector that sits between Claude and the Google Ads API.

Once it's wired up, Claude can read your campaign data directly. You ask a question in normal language; behind the scenes Claude writes the query, sends it to Google, and hands you back the answer. No GAQL to learn, no reports to build, no CSVs to wrangle.

A few things it's genuinely good at:

• Pulling performance figures across campaigns, ad groups, keywords and search terms on demand.
• Spotting patterns you'd otherwise dig for — wasted spend, high-intent search terms you're not targeting, budget-capped campaigns.
• Comparing accounts if you manage several under a manager (MCC) account.
• Turning a vague question ("where am I leaking money?") into a specific, data-backed answer.

One important caveat up front: the setup we recommend is read-only. Claude can look at everything and change nothing — it won't touch budgets, pause campaigns or edit bids. That's a feature, not a limitation. It means you can hand it your live account without a knot in your stomach.

Before you start

You'll need five things. None of them cost money, and you probably already have most:

• A Google Ads account you can sign into (ideally with admin access, or a manager/MCC account if you run several).
• A Google account that can use the Google Cloud Console.
• Claude Desktop (or Claude Code, if you prefer the command line — we cover both).
• About 30–60 minutes, most of which is waiting for a token to be approved.
• A little comfort copying and pasting into a terminal. If that sounds daunting, don't worry — we explain what each command does and there's nothing you can break.

Two servers: which one should you use?

There are two well-supported Google Ads MCP servers, and it's worth knowing the difference before you begin.

The official Google server (released in April 2026) is maintained by Google's own Ads team. It's read-only and deliberately simple — three tools that let Claude list your accounts, run reporting queries, and understand the shape of the data. Because it's official and can't make changes, it's the safest place to start, and it's the method we'll use for the main walkthrough below.

The community server (cohnen/mcp-google-ads) is an open-source project with a wider set of tools, including some that can make changes to your account. It's excellent if you want to go beyond reporting, and we cover its setup as an alternative near the end. For most people, start with the official server first.

Step 1 — Get a Google Ads developer token

A developer token is the credential that lets any tool talk to the Google Ads API on your behalf. You apply for it once, inside your Google Ads account.

• Sign in at ads.google.com (from your manager/MCC account if you have one — that's where the token lives).
• Click the Tools icon (the wrench), then under Setup open API Center.
• Accept the terms and apply for a token. Copy the token string somewhere safe — you'll need it shortly.

A quick note on access levels, because it trips people up:

• Test access is granted instantly, but it only works against test accounts — it can't read your real campaign data.
• Basic access is what you actually want. It reads live data (with generous daily limits) and is usually approved within one to two business days.
• Standard access raises those limits further and is rarely needed for a single account.

Apply for Basic access, then carry on with the rest of the setup while you wait for approval — everything else can be done in the meantime.

Step 2 — Create a Google Cloud project and OAuth credentials

The developer token proves the tool is allowed to use the API. This next step proves that you are allowed to see your account's data. It happens in the Google Cloud Console.

• Go to the Google Cloud Console and create a new project — call it something like google-ads-mcp. Make a note of the Project ID it gives you (it looks like google-ads-mcp-472310).
• Enable the API: go to APIs & Services → Library, search for Google Ads API, and click Enable.
• Set up the consent screen: under APIs & Services → OAuth consent screen, choose External, fill in the basics, and add your own Google address as a test user.
• Create the credentials: go to APIs & Services → Credentials → Create Credentials → OAuth client ID, choose Desktop app as the type, and download the JSON file. Rename it client_secret.json and save it somewhere you'll remember, such as your home folder.

Step 3 — Install the tools you'll need

Three small pieces of software do the heavy lifting: Python (the language the server is written in), pipx (which runs the server cleanly), and the gcloud CLI (which handles the Google sign-in). Here's how to get each on Mac/Linux and on Windows.

Python

On Mac, the simplest route is Homebrew:

brew install python

On Windows, download the installer from python.org and — this bit matters — tick "Add python.exe to PATH" on the first screen before clicking Install. To confirm it worked, open a fresh terminal and run:

python --version

pipx

pipx installs and runs command-line Python tools without them interfering with each other. On Mac/Linux:

python3 -m pip install --user pipx
python3 -m pipx ensurepath

On Windows (use py instead of python3):

py -m pip install --user pipx
py -m pipx ensurepath

Close and reopen your terminal afterwards so the ensurepath change takes effect.

The gcloud CLI

This is Google's own command-line tool, and it's the cleanest way to sign in. Follow Google's short installer for your operating system at cloud.google.com/sdk/docs/install, then confirm it's working:

gcloud --version

Step 4 — Sign in with gcloud

This single command opens a browser window, asks you to approve access, and stores a credential file on your computer that the server will use from then on. It's the step that connects "you" to "the API."

On Mac/Linux, run this (replace the path with wherever you saved client_secret.json). The \ at the end of each line just lets one command span several lines:

gcloud auth application-default login \
  --scopes=https://www.googleapis.com/auth/adwords,https://www.googleapis.com/auth/cloud-platform \
  --client-id-file=/Users/you/client_secret.json

On Windows, run it as a single line (no backslashes):

gcloud auth application-default login --scopes=https://www.googleapis.com/auth/adwords,https://www.googleapis.com/auth/cloud-platform --client-id-file=C:\Users\you\client_secret.json

A browser opens — sign in with the same Google account you added as a test user, and approve the permissions. When it finishes, the terminal prints the path to a file called application_default_credentials.json. That's your key. Its default home is:

• Mac/Linux: ~/.config/gcloud/application_default_credentials.json
• Windows: %APPDATA%\gcloud\application_default_credentials.json (typically C:\Users\you\AppData\Roaming\gcloud\application_default_credentials.json)

Step 5 — Tell Claude about the server

Now you point Claude at the server and give it the three details it needs: your credentials file, your Cloud project ID, and your developer token. Pick whichever Claude you use.

Option A — Claude Desktop

Open the config file. The easy way is inside the app: Settings → Developer → Edit Config. Or open it directly:

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

Paste in the block below, swapping in your own paths, project ID and token. If you manage several accounts, add your manager (MCC) ID as GOOGLE_ADS_LOGIN_CUSTOMER_ID with no dashes; otherwise you can leave that line out.

{
  "mcpServers": {
    "google-ads": {
      "command": "pipx",
      "args": [
        "run", "--spec",
        "git+https://github.com/googleads/google-ads-mcp.git",
        "google-ads-mcp"
      ],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "/Users/you/.config/gcloud/application_default_credentials.json",
        "GOOGLE_PROJECT_ID": "your-project-id",
        "GOOGLE_ADS_DEVELOPER_TOKEN": "your-developer-token",
        "GOOGLE_ADS_LOGIN_CUSTOMER_ID": "1234567890"
      }
    }
  }
}

Windows users, two small differences: in JSON you must double every backslash in a path, so the credentials line becomes "C:\\Users\\you\\AppData\\Roaming\\gcloud\\application_default_credentials.json". And if Claude reports it can't find pipx, replace "command": "pipx" with the full path pipx printed during install (something like "C:\\Users\\you\\.local\\bin\\pipx.exe").

Option B — Claude Code (command line)

If you use Claude Code, you can register the same server with one command:

claude mcp add google-ads \
  --env GOOGLE_APPLICATION_CREDENTIALS=/Users/you/.config/gcloud/application_default_credentials.json \
  --env GOOGLE_PROJECT_ID=your-project-id \
  --env GOOGLE_ADS_DEVELOPER_TOKEN=your-developer-token \
  -- pipx run --spec git+https://github.com/googleads/google-ads-mcp.git google-ads-mcp

Prefer editing a file? Add the same mcpServers block shown above to ~/.claude/settings.json instead. Run claude mcp list afterwards to confirm the server is registered.

Step 6 — Restart Claude and check the connection

MCP servers are only picked up when Claude starts, so fully quit and reopen it — on Mac that's Cmd+Q (not just closing the window); on Windows, right-click the tray icon and choose Quit. Reopen Claude and look for the tools indicator (the small plug or slider icon near the message box). You should see google-ads listed with its three tools.

Now test it. Ask Claude:

List the Google Ads accounts I can access.

Claude will call the list_accessible_customers tool and return your account IDs. If you see them, you're connected.

Step 7 — Put it to work

The whole point is that you never have to write a query yourself. Ask in plain language and let Claude do the translating. A few prompts to get you started:

• "For customer 123-456-7890, show me each campaign's cost, conversions and CPA over the last 30 days, sorted by spend."
• "Find search terms from the last 30 days with a conversion rate above 3% that aren't already added as keywords."
• "Which of my campaigns are limited by budget, and how much impression share am I losing to it?"
• "Compare CPA across my bidding strategies and tell me which is pulling its weight."

Under the hood, Claude is writing GAQL (Google Ads Query Language) and sending it to the API. If you're curious, just ask it to "show me the query you ran" — a handy way to learn GAQL by example.

Alternative: the community server, for more than reporting

If read-only isn't enough and you're comfortable with a little more setup, the community cohnen/mcp-google-ads server offers a wider toolset. The install uses uv (a fast Python package manager) and a local copy of the project:

git clone https://github.com/cohnen/mcp-google-ads.git
cd mcp-google-ads
uv venv .venv
source .venv/bin/activate
uv pip install -r requirements.txt

On Windows, the one line that differs is activating the environment — use .venv\Scripts\activate instead of the source line. Its Claude config points command at the project's Python and script, with the token and a path to your client_secret.json in the environment variables (its README lists the exact keys). The trade-off is simple: more power in exchange for a community-maintained tool — so review what a tool does before you let it change anything in a live account.

Troubleshooting

• The server won't appear / red indicator. Nine times out of ten it's the config file. Check the JSON is valid (a stray trailing comma is the usual culprit), make sure every path is absolute, then fully restart Claude.
• "Developer token is not approved." A test token only works on test accounts. Make sure you applied for Basic access and that it's been granted.
• Authentication errors. Re-run the gcloud auth application-default login command from Step 4, and double-check both scopes (adwords and cloud-platform) are included.
• "pipx: command not found." Run pipx ensurepath again and restart your terminal. On Windows, use the full path to pipx.exe in the config, or py -m pipx.
• "Customer not found" or permission errors. Add GOOGLE_ADS_LOGIN_CUSTOMER_ID (your manager account ID, digits only, no dashes) to the config.
• Windows paths. Remember to double every backslash inside the JSON config file.

What it can (and can't) do — and a word on safety

With the official server, Claude is a fast, tireless analyst that can read everything and change nothing. It's brilliant for reporting, spotting opportunities and answering "what's going on in my account?" — but it won't adjust budgets, bids or campaign status. If you want those actions, that's the community server's territory, and it deserves extra care.

On security: your developer token and credential files live on your own machine, and the connection runs between your computer, Google and Claude. Treat the setup like handing someone a read-only key to your account. Use a dedicated Google Cloud project, keep your token out of any shared or synced config, and remember you can revoke access at any time from the Google Cloud Console.

The bottom line

Connecting Google Ads to Claude turns a chat window into an analyst that sits directly on top of your account data — one that answers in seconds and never gets tired of "just one more question." What it won't do is decide which questions matter, or what to do with the answers. That judgement — knowing which levers move the numbers, and when to pull them — is still where the real returns come from.

If you'd rather have that judgement working for you than build the pipes yourself, that's exactly what we do. Get a free growth plan and we'll turn your account data into a plan you can act on.