AdLoop

The AI command center for Google Ads, GA4, and tracking code.

An MCP server that gives your AI assistant read + write access to Google Ads and GA4 — with safety guardrails that prevent accidental spend.

☁️ Skip the setup — use AdLoop Cloud (free beta)  ·  or self-host: pip install adloop

Cloud or Self-Hosted?

Both versions run the same 67 tools with the same safety model. The difference is who handles the plumbing:

Not sure? Start with Cloud — it's the fastest way to see what AdLoop can do, and it's the only way to use AdLoop from claude.ai or ChatGPT. Self-host when you want everything on your own machine or need to modify the code. And if you're here to hack on AdLoop itself: welcome, keep scrolling.

Related MCP server: PaidSync (Ads analysis & Management)

What It Solves

AdLoop exists because managing Google Ads alongside your code is a mess. These are the specific problems it handles:

• "My conversions dropped and I don't know why." AdLoop cross-references Ads clicks, GA4 sessions, and conversion events in one query. It detects whether the gap is from GDPR consent rejection, broken tracking, or an actual landing page problem — before you waste hours checking each dashboard separately.

• "I'm wasting ad spend on irrelevant searches." Pull your search terms report, identify the junk, and add negative keywords — all from a single conversation in your IDE. No context-switching to the Ads UI.

• "Is my tracking even working?" Compare the event names in your actual codebase against what GA4 is receiving. Find the mismatches: events you fire that GA4 never sees, events GA4 records that you didn't know about.

• "I need to create ads but the Google Ads UI is hostile." Draft responsive search ads, create campaigns, add keywords — all through natural language. Every change shows a preview first. Nothing goes live without your explicit confirmation. New ads and campaigns start paused.

• "My landing page gets paid traffic but nobody converts." AdLoop joins your ad final URLs with GA4 page-level data. See which pages get clicks but no conversions, which have high bounce rates, and which ones are orphaned from any ad campaign.

• "Are conversions even being tagged on every page?" AdLoop reads your live Google Tag Manager container, joins it against the events in your codebase and the events firing in GA4, and tells you exactly which conversions are being captured, which tags are paused, which page-scope filters are too narrow, and which codebase events have no tag at all — the kind of three-way audit GTM Preview can't give you in a single view.

• "I don't know if my EU consent setup is causing data gaps." In Europe, 30-70% of users reject analytics cookies. AdLoop accounts for this automatically — it won't diagnose a normal GDPR consent gap as broken tracking.

Built From Real Usage

Every tool exists because of an actual problem hit while running real Google Ads campaigns. The cross-reference tools exist because we kept manually asking the AI to "get Ads data, then get GA4 data, then compare them" — so we automated the join. The Broad Match + Manual CPC safety rule exists because the AI once created that exact combination and wasted budget. The GDPR consent awareness exists because the AI kept diagnosing normal EU cookie rejection as broken tracking.

The best features come from real workflows. If you're using AdLoop and find yourself wishing it could do something it can't, open an issue describing your situation — not just "add feature X" but "I was trying to do Y and couldn't because Z." The context matters more than the request.

All 67 Tools

Quick start: pip install adloop or git clone https://github.com/kLOsk/adloop.git && cd adloop && uv sync && uv run adloop init — or zero setup on AdLoop Cloud

Diagnostics

GA4 Read Tools

Google Ads Read Tools

Compact mode — get_campaign_performance, get_keyword_performance, get_search_terms, and get_ad_performance accept compact=true: account totals, breakdowns, top-10 rows, and pre-computed offender lists (zero-conversion spenders, low-QS keywords, negative-keyword candidates, thin RSAs) instead of every row. ~90% smaller responses — built for account audits so raw tables don't flood your AI's context.

Cross-Reference Tools (GA4 + Ads Combined)

These tools call both APIs internally and return unified results with auto-generated insights. They're the core of what makes AdLoop different from having separate GA4 and Ads tools.

Tracking Tools

Google Tag Manager Tools

These tools read the live GTM container and join it with the codebase + GA4 to find tracking gaps that pure GA4 inspection can't catch — page-scoped triggers, paused tags, dynamic event names, brittle CSS selectors, and codebase events with no tag wired up at all.

Setup for GTM tools — Enable the Tag Manager API v2 in your GCP project, then add your AdLoop credentials' email (the OAuth user, or the service account email if using a service account) as a Read user on the GTM container under Admin → User Management. Service accounts pick up access on the next call. OAuth users upgrading from an earlier AdLoop version must re-authorize once: the GTM scope is new, so delete ~/.adloop/token.json and run any tool to re-consent — until then GTM tools return a permissions error.

Search Console Tools

Web Performance Tools

Merchant Center Tools

Setup for Merchant Center tools — Enable the Merchant API in your GCP project (the Content API for Shopping is deprecated). The Merchant API has no read-only scope; AdLoop uses it strictly read-only. Upgrading OAuth users re-authorize once.

Setup for GSC tools — Enable the Search Console API in your GCP project. Upgrading OAuth users must re-authorize once for the new scope (delete ~/.adloop/token.json, run any tool). The killer combo: cross-reference organic queries with get_keyword_performance to find paid/organic cannibalization and untapped keyword opportunities.

Planning Tools

Google Ads Write Tools

All write operations follow a draft → preview → confirm workflow. Nothing executes without explicit approval.

Orchestration Rules

AdLoop ships with orchestration rules that teach the AI how to combine these tools — marketing workflows, GAQL syntax, safety protocols, GDPR awareness, and best practices. Without rules, the AI has tools but doesn't know the playbook.

• Cursor: .cursor/rules/adloop.mdc (canonical source)

• Claude Code: .claude/rules/adloop.md (synced from Cursor rules via scripts/sync-rules.py)

The rules include:

• Orchestration patterns for common workflows (performance review, conversion diagnosis, campaign creation, negative keyword hygiene, keyword discovery, tracking validation, budget planning, landing page analysis)

• GAQL quick reference with syntax, common queries, and gotchas

• Safety rules including Broad Match + Manual CPC prevention and pre-write validation

• Ad copy character limit guidance (30-char headlines are shorter than you think)

• GDPR consent awareness to prevent false tracking diagnoses in EU markets

Slash Commands (Claude Code)

AdLoop includes pre-built slash commands in .claude/commands/ for common workflows:

Safety Model

AdLoop manages real ad spend, so safety is not optional.

• Two-step writes. Every mutation returns a preview first. A separate confirm_and_apply call is required to execute.

• Dry-run by default. Even confirm_and_apply defaults to dry_run=true. Real changes require explicit dry_run=false.

• Budget caps. Configurable maximum daily budget — the server rejects anything above the cap.

• Audit log. Every operation (including dry runs) is logged to ~/.adloop/audit.log.

• New campaigns and ads are PAUSED. Nothing goes live without manual enablement.

• Destructive ops require double confirmation. Removing entities or large budget increases trigger extra warnings.

• Broad Match + Manual CPC blocked. The #1 cause of wasted ad spend is automatically prevented — draft_keywords refuses to add BROAD match keywords to campaigns without Smart Bidding.

• Pre-write validation. Before any write, the AI checks bidding strategy, conversion tracking status, and quality scores. If the campaign is fundamentally broken, AdLoop warns you instead of making things worse.

• Structured error handling. All tools return actionable error messages with hints instead of raw exceptions. Auth errors include specific re-authorization steps.

• API version pinning. The Google Ads API version is pinned to prevent silent breaking changes from library updates. health_check warns when a newer version is available.

• Ask mode compatibility. Read tools declare readOnlyHint so they work in Cursor's Ask mode without switching to Agent mode.

Setup

AdLoop uses your own (free) Google Cloud project for OAuth. The adloop init wizard walks you through it — a one-time setup of about 5 minutes, with no shared user caps and no waiting on anyone's verification review. AdLoop does not ship built-in OAuth credentials.

Prefer zero setup? AdLoop Cloud is the hosted version: connect Google in two clicks — no Cloud project, no developer token, EU-hosted.

(Upgrading from ≤0.9 with built-in credentials? Those sign-ins were retired in 0.10 — run adloop init once to switch to your own project.)

Install

From PyPI:

pip install adloop
adloop init

From source:

git clone https://github.com/kLOsk/adloop.git
cd adloop
uv sync
uv run adloop init

What adloop init does

The wizard walks you through:

1. Google Cloud setup — creates a project, enables the three APIs, generates an OAuth client (see Custom Google Cloud Project Setup below for the exact steps the wizard refers you to)

2. Developer token — from your Google Ads MCC (API Center)

3. MCC Account ID — your Manager Account ID (top bar in the MCC UI)

4. OAuth sign-in — opens a browser to sign in with Google (or prints a URL for headless servers)

5. Auto-discovers your accounts — finds your GA4 properties and Ads accounts automatically

6. Safety defaults — budget cap and dry-run preference

7. Editor config snippets — prints MCP configuration for both Cursor and Claude Code

Requirements

• Python 3.11+

• A Google Ads account with an MCC (Manager Account)

• A Google Ads Developer Token (see below)

Google Ads Developer Token

A developer token is always required. Your OAuth client handles Google sign-in; the developer token is a separate key that grants API access to your Google Ads data.

1. Create an MCC (free) at ads.google.com/home/tools/manager-accounts if you don't have one. Link your regular Google Ads account to it.

2. In the MCC, go to Tools & Settings → API Center

3. Your developer token is shown there. Copy it — the wizard will ask for it.

Access levels — your token's access level determines what it can do:

Getting DEVELOPER_TOKEN_NOT_APPROVED? Your token is at "Test Account" level. Go to API Center in your MCC and check your access level. If it shows "Test Account", you need to apply for Basic access or wait for Explorer access to be granted after your first production API call.

Headless Servers

Running on a server without a browser (VMs, Docker, SSH)? The wizard automatically detects this and falls back to a manual flow: it prints an authorization URL you can open on any device, then you paste the redirect URL back into the terminal.

Custom Google Cloud Project Setup

The wizard refers to these steps — do them in your browser before running adloop init (or while it waits at the OAuth prompt).

Step 1 — Google Cloud Project

1. Go to console.cloud.google.com and create a new project

2. Enable these three APIs (search for each in the API Library):

   • Google Analytics Data API — for GA4 reports and events

   • Google Analytics Admin API — for listing GA4 properties

   • Google Ads API — for all ads operations

Step 2 — OAuth Credentials

1. In your Google Cloud project, go to APIs & Services → Credentials

2. Click Create Credentials → OAuth client ID

3. Select Desktop app as the application type, give it any name

4. Download the JSON file and save it as ~/.adloop/credentials.json

Service accounts are also supported — just place the service account key JSON at the same credentials_path. AdLoop detects the file type automatically.

Step 3 — Connect to Your Editor

Cursor — Add to your project's .cursor/mcp.json:

{
  "mcpServers": {
    "adloop": {
      "command": "/absolute/path/to/adloop/.venv/bin/python",
      "args": ["-m", "adloop"]
    }
  }
}

Then copy .cursor/rules/adloop.mdc from this repo into your project's .cursor/rules/ directory.

Claude Code — Run:

claude mcp add --transport stdio adloop -- /absolute/path/to/adloop/.venv/bin/python -m adloop

Or add to your project's .mcp.json:

{
  "mcpServers": {
    "adloop": {
      "command": "/absolute/path/to/adloop/.venv/bin/python",
      "args": ["-m", "adloop"]
    }
  }
}

Then install the orchestration rules + slash commands globally so every Claude Code session inherits them:

adloop install-rules

This writes a managed block to ~/.claude/CLAUDE.md and copies the slash commands (prefixed adloop-*) into ~/.claude/commands/. The block is delimited by sentinel comments so it's safe to run multiple times — re-running just refreshes the content. Two install modes:

• inline (default) — full rules embedded in ~/.claude/CLAUDE.md. Reliable but adds ~10K tokens to every Claude Code session.

• lazy (adloop install-rules --lazy) — small directive in CLAUDE.md pointing at ~/.claude/rules/adloop.md. Cheaper baseline cost; the LLM reads the rules file only when AdLoop tools are in scope.

To refresh after upgrading AdLoop: adloop update-rules. To remove cleanly: adloop uninstall-rules — only the managed block and adloop-* commands are touched, never your own content.

If you'd rather manage things by hand instead, copy .claude/rules/adloop.md and .claude/commands/ from this repo into your project's .claude/ directory.

Claude Desktop / claude.ai has no programmatic rules location. Run adloop install-rules and it will print the rules content for you to paste into Project settings → Custom instructions on claude.ai.

Use It

Ask your AI assistant things like:

• "How are my Google Ads campaigns performing this month?"

• "Which search terms are wasting budget? Add them as negative keywords."

• "My sign-up conversions dropped — check GA4 and Ads to find out why."

• "Draft a new responsive search ad for my main campaign."

• "Which landing pages get paid traffic but don't convert?"

• "Is my tracking set up correctly? Compare my codebase events against GA4."

• "Audit my Google Tag Manager container — which conversions are being captured and where are the gaps?"

• "What keywords should I target for [product]? Find ideas and estimate the budget."

• "How much budget would I need for these keywords in Germany?"

• "Create a new search campaign for [product feature] with a €20/day budget."

Configuration Reference

All configuration lives in ~/.adloop/config.yaml. See config.yaml.example for a documented template.

Project Structure

src/adloop/
├── __init__.py        # Entry point — routes 'adloop init' to wizard, otherwise starts MCP server
├── server.py          # FastMCP server — 67 tool registrations with safety annotations
├── config.py          # Config loader (~/.adloop/config.yaml)
├── auth.py            # OAuth 2.0 flow (user-supplied credentials, headless fallback) + service accounts; GA4 / Ads / GTM scopes
├── cli.py             # Interactive 'adloop init' setup wizard
├── crossref.py        # Cross-reference tools (GA4 + Ads + GTM combined analysis)
├── tracking.py        # Tracking validation + code generation tools
├── ga4/
│   ├── client.py      # GA4 Data + Admin API clients
│   ├── reports.py     # Account summaries, reports, realtime
│   └── tracking.py    # Event discovery
├── ads/
│   ├── client.py      # Google Ads API client (version-pinned) + retry/backoff for rate limits
│   ├── gaql.py        # GAQL query execution with human-readable error parsing
│   ├── read.py        # Campaign, ad, keyword, search term, negative keyword, shared sets, recommendations, audience reads
│   ├── pmax.py        # Performance Max tools — campaign/asset group performance, asset labels, top combinations
│   ├── write.py       # Draft campaign, RSA, keywords; pause, enable, remove, confirm
│   └── forecast.py    # Budget estimation + keyword discovery via Keyword Planner API
├── gtm/
│   ├── client.py      # Google Tag Manager API v2 client
│   └── read.py        # Live container fetching, tag/trigger/variable parsing, workspace diff, version history
└── safety/
    ├── guards.py      # Budget caps, bid limits, blocked operations, Broad Match safety
    ├── preview.py     # Change plans and previews
    └── audit.py       # Mutation audit logging

Roadmap

What's been shipped and what's next:

• GA4 read tools ✓

• Google Ads read + write tools with safety layer ✓

• Cross-reference intelligence (campaign→conversion mapping, landing page analysis, attribution comparison) ✓

• Tracking utilities (validate events against GA4, generate gtag code) ✓

• Budget estimation + keyword discovery via Keyword Planner ✓

• Shared negative keyword lists (SharedSet API) ✓

• Retry/backoff for API rate limits ✓

• Setup wizard (adloop init) ✓

• Claude Code support ✓ — CLAUDE.md, .mcp.json, .claude/rules/, .claude/commands/, CLI wizard snippets

• Claude Desktop one-click install — adloop install claude-desktop (and/or a .dxt extension bundle) that writes the AdLoop MCP entry into claude_desktop_config.json automatically, so Claude Desktop + Cowork users don't have to hand-edit JSON

• PyPI package ✓ — pip install adloop

• AdLoop Cloud ✓ — the hosted version, live in beta: no Google Cloud project, no developer token, connect Google in two clicks (EU-hosted, GDPR-first)

• Headless server support ✓ — manual URL copy-paste flow for servers without a browser

• Behavioral eval suites ✓ — 28 prompt-and-expectation tests covering read, write, tracking, and planning workflows

• Google Tag Manager integration ✓ — read tools for tags, triggers, variables, workspaces, and version history, plus the audit_event_coverage three-way join across codebase events, GTM tags, and GA4 actual fires

• Community launch — HN, Indie Hackers, r/cursor, Twitter

• Video walkthrough

Contributing

See CONTRIBUTING.md for guidelines. The short version: open an issue describing your situation first, then submit a PR if you want to build it.

License

MIT — see LICENSE.

Privacy

The open-source version runs entirely on your machine. No data is collected, stored, or transmitted to any server. See PRIVACY.md for the full privacy policy. AdLoop Cloud has its own privacy policy and DPA.

If AdLoop helps you run Google Ads, GA4, and tracking code from one place — give it a star or try the hosted version.

Made by @kLOsk | AdLoop Cloud | Privacy Policy