MCP Google Ads auf Claude Desktop 2026

MCP (Model Context Protocol), das Anthropic im November 2024 startete, hat im offiziellen Verzeichnis bis Ende Q1 2026 mehr als 200 öffentliche Server überschritten (modelcontextprotocol.io), mit beschleunigter Adoption unter Claude Desktop, Cursor und Claude Code Power Usern. Doch es existieren 2026 weniger als 5 öffentliche MCP-Server für Google Ads — das ist eine der größten Lücken im Ökosystem, und genau das, was wir in diesem Leitfaden füllen werden. Auf aggregierten Google Ads Daten 2025-2026 beobachtete Größenordnung: Ein PPC Manager, der einen MCP-getriebenen Workflow adoptiert, gewinnt typischerweise 25 bis 40 % der operativen Zeit zurück, abhängig von der Kontogröße, mit einer Spanne zwischen 18 % und 52 % je nach Branche (reifes E-Com höchster Gewinn, B2B Lead Gen moderater wegen langer Zyklen).

Hier ist genau, wie man einen Google Ads MCP-Server in TypeScript baut: Architektur, Copy-Paste TypeScript-Code, OAuth-Setup, exponierte Tools, Claude-Desktop-Konfiguration. Am Ende des Leitfadens haben Sie ein Setup, in dem das Tippen von "Audit mein Google Ads Konto" in Claude Desktop ein echtes Audit über Ihren MCP-Server auslöst. Das GitHub-Repo github.com/steerads/mcp-google-ads-server enthält den vollständigen dokumentierten Code. Voraussetzungen: Node.js 18+, ein Google Ads Konto, ein API developer_token (siehe unseren Google Ads API Python Setup-Guide für das OAuth-Verfahren, identisch auf TypeScript-Seite). Wenn Sie neu in der Google Ads Automatisierung sind, lesen Sie zuerst unseren Guide mit 10 ready-to-copy Skripten. Unser Wasted Ad Spend Calculator schätzt das verbrannte $/Monat aus Broad-ohne-Negatives oder übermäßigem LP-Bounce.

Was ist MCP und wozu für Google Ads?

MCP (Model Context Protocol) ist ein Open-Source-Protokoll, das Anthropic im November 2024 veröffentlicht hat, um zu standardisieren, wie LLMs (Claude, aber auch kompatibel mit anderen Modellen) externe Daten und Tools konsumieren. Stellen Sie es sich als Äquivalent zu LSP (Language Server Protocol) für IDEs vor: ein Client-Server-Protokoll, bei dem der Client eine LLM-App ist (Claude Desktop, Claude Code, Cursor, Zed) und der Server Ressourcen (zu lesende Daten), Prompts (vorformatierte Templates) und Tools (aufzurufende Funktionen) über eine standardisierte JSON-RPC-Schnittstelle exponiert.

Für Google Ads ist der Nutzen unmittelbar. Statt manuell Daten in der Google Ads Oberfläche abzurufen (10 Klicks, um eine Statistik zu ziehen), tippen Sie in natürlicher Sprache in Claude Desktop: "Was sind meine 5 Keywords mit dem höchsten CPA diese Woche?", und Claude ruft automatisch ein von Ihrem MCP-Server exponiertes pull_keyword_performance Tool auf, liest die Antwort und formuliert eine Analyse in klarer Sprache. Es ist der PPC Manager Workflow als konversationell neu gedacht.

Drei konkrete Vorteile, die in öffentlichen Benchmarks auf Produktions-MCP-Google-Ads-Setups beobachtet werden:

1. Zeitersparnis bei Ad-hoc-Abfragen: 5 bis 15 Minuten pro Analyse-Session gespart (kein Interface-Login, kein manuelles Filtern, kein Copy/Paste nach Excel).
2. Konto-übergreifende Synthese: Ein MCP-Server kann 10 Konten parallel abfragen und Insights synthetisieren — auf der Scripts-Seite unmöglich.
3. Konversationelles Debugging: "Warum ist der CPA in Kampagne X gestern explodiert?" löst ein Multi-Faktor-Audit aus (CPC, CTR, Conv Rate, Search Terms, IS), ohne dass Sie wissen müssen, welche Reports zu konsultieren sind.

MCP ist NICHT geeignet für: Cron-basierte Automatisierungen (ein MCP-Server wartet darauf, dass ein Mensch über Claude Desktop interagiert, kein Scheduler), Bulk-Mutationen über 1.000 Entitäten hinaus (falsches Medium) oder Operationen, die eine reichhaltige UI erfordern (interaktive Charts, Drag-Drop). Für diese Fälle bleiben die Standalone Python API oder Google Ads Scripts die richtigen Werkzeuge.

Architektur: Claude Desktop -> MCP Server -> Google Ads API

Die Architektur eines MCP-Google-Ads-Setups folgt einem klassischen Client-Server-Muster, aufgeteilt in drei Schichten: einen LLM-Client (Claude Desktop, Cursor, Claude Code), der die Konversation und die Entscheidung zum Tool-Aufruf orchestriert; einen MCP-Server (Ihr Code), der einen Tool-Katalog über das JSON-RPC-Protokoll exponiert; und eine darunter liegende Business-API (hier Google Ads API v17), die echte Operationen ausführt. Diese Trennung macht den Server wiederverwendbar: eine einzige TypeScript-Codebasis, mehrere mögliche Clients. In den von uns deployten Setups liegt der initiale Entwicklungsaufwand in der Größenordnung von 4 bis 8 Stunden für einen MCP-Server mit 4 Tools, und das Verhältnis von eingesparter zu investierter Zeit kippt im Schnitt innerhalb von 2 bis 3 Wochen Nutzung.

Schicht 1: Claude Desktop. Anthropics offizielle Desktop-App, verfügbar für Mac und Windows (claude.ai/desktop). Sie hostet die konversationelle Erfahrung, entdeckt installierte MCP-Server über die Konfigurationsdatei und orchestriert Tool-Aufrufe. Sie sprechen mit Claude, Claude entscheidet, Ihre Tools aufzurufen.

Schicht 2: MCP-Server (Ihr Code). Ein Node.js-Prozess (oder Python, Rust, Go — egal), der das MCP-Protokoll über stdin/stdout (lokaler stdio-Modus) oder HTTP/SSE (Remote-Modus) implementiert. Der Server exponiert eine Tool-Liste, jedes mit einem Namen, einer Beschreibung und einem Argument-Schema. Bei jedem Tool-Aufruf durch Claude führt der Server den Code aus und gibt ein strukturiertes Ergebnis zurück.

Schicht 3: Google Ads API. Die google-ads-api Bibliothek (Node.js-Port der offiziellen Bibliothek, community-gepflegt) abstrahiert GAQL-Aufrufe und Mutationen. Der MCP-Server authentifiziert sich beim Start via OAuth2 + developer_token, dann nutzt er den Client, um die API bei jedem Tool-Aufruf zu rufen.

Der lokale stdio-Modus ist für die individuelle Nutzung weitgehend ausreichend: Der Server läuft auf Ihrer Maschine, Claude Desktop spawnt ihn als Subprozess, Kommunikation via stdin/stdout JSON-RPC. Kein Netzwerk, nahezu null Latenz, Credentials nie über Ihre Maschine hinaus exponiert. Der Remote-HTTP/SSE-Modus wird für Teams relevant, die einen MCP-Server teilen (z. B. eine Agentur mit 5 PPC Managern, die auf denselben Server zeigen). Für diesen Leitfaden bleiben wir beim lokalen stdio.

Die Tabelle unten vergleicht die beiden Transports, um die richtige Wahl für Ihr Setup zu treffen:

Claude Desktop Setup und MCP-Konfiguration

Bevor Sie den Server codieren, konfigurieren Sie Claude Desktop, um MCP-Server zu entdecken. Laden Sie Claude Desktop von claude.ai/desktop herunter, installieren Sie es, melden Sie sich mit einem Anthropic-Konto an.

Die Claude Desktop MCP-Konfigurationsdatei ist:

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

Wenn die Datei nicht existiert, erstellen Sie sie. Hier ist die Basisstruktur:

{
  "mcpServers": {
    "google-ads": {
      "command": "node",
      "args": [
        "/Users/youruser/dev/mcp-google-ads-server/dist/index.js"
      ],
      "env": {
        "GOOGLE_ADS_DEVELOPER_TOKEN": "YOUR_DEVELOPER_TOKEN",
        "GOOGLE_ADS_CLIENT_ID": "YOUR_CLIENT_ID",
        "GOOGLE_ADS_CLIENT_SECRET": "YOUR_CLIENT_SECRET",
        "GOOGLE_ADS_REFRESH_TOKEN": "YOUR_REFRESH_TOKEN",
        "GOOGLE_ADS_LOGIN_CUSTOMER_ID": "1234567890",
        "GOOGLE_ADS_DEFAULT_CUSTOMER_ID": "1112223333",
        "READ_ONLY_MODE": "false"
      }
    }
  }
}

Drei wichtige Schlüssel:

• command: der Befehl zum Start des Servers. Hier node, weil TypeScript kompiliert, könnte aber python, npx etc. sein.
• args: absoluter Pfad zum Server-Build. Vermeiden Sie relative Pfade oder unaufgelöstes ~.
• env: Umgebungsvariablen, die an den Server übergeben werden. Hier injizieren Sie Google Ads Credentials.

Sicherheitshinweis: Diese Datei enthält Ihre Google Ads Credentials im Klartext. Committen Sie sie NIEMALS zu Git, teilen Sie sie NIEMALS. Für ein Team erwägen Sie ein Wrapper-Skript, das Creds beim Start aus einem Secret Manager lädt.

Um zu validieren, dass Claude Desktop Ihren Server sieht, öffnen Sie nach dem Neustart von Claude Desktop eine neue Konversation und tippen Sie "Welche MCP-Server sind verfügbar?". Claude sollte google-ads mit seinen Tools auflisten (nach dem ersten Lauf, der sie aufzählt).

Einen MCP-Server in TypeScript schreiben: 4 Schlüssel-Tools

Ein MCP-Tool ist die minimale Erweiterungseinheit für das LLM: eine benannte Funktion, in klarem Text beschrieben, parametriert durch ein JSON-Schema, die eine Operation ausführt und ein strukturiertes Ergebnis zurückgibt. Das offizielle @modelcontextprotocol/sdk liefert das Server-Skelett und das Tool-Routing; Sie liefern die Business-Logik. Die empirische Regel, die wir auf Produktions-Setups anwenden: 6 bis 12 Tools pro MCP-Server, fokussiert auf atomare Operationen (ein Tool = ein Business-Verb), mit Beschreibungen unter 200 Zeichen, damit das LLM korrekt wählt. Die unten entwickelten 4 Tools (search_campaigns, get_account_audit, pull_report, add_negative) decken in den meisten Fällen 70 bis 80 % der Fragen ab, die ein PPC Manager täglich behandelt.

mcp-google-ads-server/
├── src/
│   ├── index.ts          # Entry point + MCP server setup
│   ├── google-ads.ts     # Google Ads API client wrapper
│   ├── tools/
│   │   ├── search-campaigns.ts
│   │   ├── account-audit.ts
│   │   ├── pull-report.ts
│   │   └── add-negative.ts
│   └── types.ts
├── package.json
├── tsconfig.json
└── .env.example

Die minimale package.json:

{
  "name": "mcp-google-ads-server",
  "version": "0.1.0",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "dev": "ts-node src/index.ts"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^0.5.0",
    "google-ads-api": "^17.0.0",
    "zod": "^3.22.0"
  },
  "devDependencies": {
    "typescript": "^5.3.0",
    "ts-node": "^10.9.0",
    "@types/node": "^20.10.0"
  }
}

Der src/index.ts Entry Point initialisiert den MCP-Server und registriert die Tools:

// src/index.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { searchCampaignsTool } from "./tools/search-campaigns.js";
import { accountAuditTool } from "./tools/account-audit.js";
import { pullReportTool } from "./tools/pull-report.js";
import { addNegativeTool } from "./tools/add-negative.js";

const server = new Server(
  { name: "google-ads-mcp", version: "0.1.0" },
  { capabilities: { tools: {} } }
);

const TOOLS = [
  searchCampaignsTool,
  accountAuditTool,
  pullReportTool,
  addNegativeTool,
];

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: TOOLS.map((t) => ({
    name: t.name,
    description: t.description,
    inputSchema: t.inputSchema,
  })),
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const tool = TOOLS.find((t) => t.name === request.params.name);
  if (!tool) {
    throw new Error(`Unknown tool: ${request.params.name}`);
  }

  try {
    const result = await tool.handler(request.params.arguments);
    return {
      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
    };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    return {
      content: [{ type: "text", text: `Error: ${msg}` }],
      isError: true,
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);
console.error("[MCP] google-ads server started on stdio");

Hinweis: console.error statt console.log, weil stdout für das JSON-RPC-Protokoll reserviert ist. Loggen Sie alles über stderr, um den Kommunikationskanal nicht zu verschmutzen. Diese Regel ist nicht verhandelbar: Ein einziger verirrter console.log reicht aus, um das JSON-Parsing des Clients zu brechen und die Konversation crashen zu lassen. Zum Debuggen in der Entwicklung ist das empfohlene Muster, einen strukturierten Logger (pino, winston) zu verwenden, der als Write Stream auf stderr konfiguriert ist, mit einem über env-var einstellbaren Verbosity Level. Auf Produktionsservern, die wir deployen, beobachten wir häufig 30-60 % der initialen Troubleshooting-Zeit, die durch Stream-Verschmutzungsprobleme absorbiert wird, die verschwinden, sobald der Logger korrekt verkabelt ist.

Der Google Ads Wrapper in src/google-ads.ts:

// src/google-ads.ts
import { GoogleAdsApi } from "google-ads-api";

let clientInstance: GoogleAdsApi | null = null;

export function getGoogleAdsClient(): GoogleAdsApi {
  if (clientInstance) return clientInstance;

  clientInstance = new GoogleAdsApi({
    client_id: process.env.GOOGLE_ADS_CLIENT_ID!,
    client_secret: process.env.GOOGLE_ADS_CLIENT_SECRET!,
    developer_token: process.env.GOOGLE_ADS_DEVELOPER_TOKEN!,
  });

  return clientInstance;
}

export function getCustomer(customerId?: string) {
  const id = customerId || process.env.GOOGLE_ADS_DEFAULT_CUSTOMER_ID!;
  const loginId = process.env.GOOGLE_ADS_LOGIN_CUSTOMER_ID!;

  const client = getGoogleAdsClient();
  return client.Customer({
    customer_id: id,
    login_customer_id: loginId,
    refresh_token: process.env.GOOGLE_ADS_REFRESH_TOKEN!,
  });
}

Das search-campaigns Tool, das flexible GAQL-Suche exponiert:

// src/tools/search-campaigns.ts
import { z } from "zod";
import { getCustomer } from "../google-ads.js";

const inputSchema = {
  type: "object",
  properties: {
    customer_id: {
      type: "string",
      description: "Google Ads customer ID (10 digits, no dashes). Default if omitted.",
    },
    status_filter: {
      type: "string",
      enum: ["ENABLED", "PAUSED", "REMOVED", "ALL"],
      description: "Campaign status filter. Default: ENABLED.",
    },
    date_range: {
      type: "string",
      description: "GAQL date range: TODAY, LAST_7_DAYS, LAST_30_DAYS, etc.",
    },
    limit: {
      type: "number",
      description: "Max number of campaigns to return. Default: 50.",
    },
  },
};

export const searchCampaignsTool = {
  name: "search_campaigns",
  description:
    "List Google Ads campaigns with their KPI (impressions, clicks, cost, conversions, CTR, CPA) " +
    "filtered by status and date range. Returns top campaigns by spend.",
  inputSchema,
  handler: async (args: any) => {
    const customer = getCustomer(args?.customer_id);
    const status = args?.status_filter || "ENABLED";
    const dateRange = args?.date_range || "LAST_30_DAYS";
    const limit = args?.limit || 50;

    const statusClause =
      status === "ALL" ? "" : `AND campaign.status = '${status}'`;

    const query = `
      SELECT
        campaign.id, campaign.name, campaign.status,
        metrics.impressions, metrics.clicks,
        metrics.cost_micros, metrics.conversions,
        metrics.ctr, metrics.average_cpc
      FROM campaign
      WHERE segments.date DURING ${dateRange} ${statusClause}
      ORDER BY metrics.cost_micros DESC
      LIMIT ${limit}
    `;

    const rows = await customer.query(query);

    return rows.map((r: any) => ({
      id: r.campaign.id,
      name: r.campaign.name,
      status: r.campaign.status,
      impressions: r.metrics.impressions,
      clicks: r.metrics.clicks,
      cost_usd: (Number(r.metrics.cost_micros) / 1_000_000).toFixed(2),
      conversions: r.metrics.conversions,
      ctr_pct: (Number(r.metrics.ctr) * 100).toFixed(2),
      cpc_usd: (Number(r.metrics.average_cpc) / 1_000_000).toFixed(2),
      cpa_usd:
        Number(r.metrics.conversions) > 0
          ? (
              Number(r.metrics.cost_micros) /
              1_000_000 /
              Number(r.metrics.conversions)
            ).toFixed(2)
          : null,
    }));
  },
};

Das account-audit Tool, das eine High-Level-Audit-Sicht aggregiert:

// src/tools/account-audit.ts
import { getCustomer } from "../google-ads.js";

export const accountAuditTool = {
  name: "get_account_audit",
  description:
    "Run a high-level audit of the Google Ads account: total spend last 30 days, " +
    "campaign types breakdown, top 5 campaigns by spend, conversion volume, " +
    "average CPA. Returns a structured audit report.",
  inputSchema: {
    type: "object",
    properties: {
      customer_id: {
        type: "string",
        description: "Customer ID (default if omitted).",
      },
    },
  },
  handler: async (args: any) => {
    const customer = getCustomer(args?.customer_id);

    // 1. Account totals
    const totals = await customer.query(`
      SELECT
        metrics.cost_micros, metrics.clicks,
        metrics.conversions, metrics.impressions
      FROM customer
      WHERE segments.date DURING LAST_30_DAYS
    `);

    // 2. Top 5 campaigns
    const top5 = await customer.query(`
      SELECT campaign.name, metrics.cost_micros, metrics.conversions
      FROM campaign
      WHERE campaign.status = 'ENABLED'
        AND segments.date DURING LAST_30_DAYS
      ORDER BY metrics.cost_micros DESC LIMIT 5
    `);

    // 3. Campaign types breakdown
    const types = await customer.query(`
      SELECT
        campaign.advertising_channel_type,
        metrics.cost_micros
      FROM campaign
      WHERE campaign.status = 'ENABLED'
        AND segments.date DURING LAST_30_DAYS
    `);

    const totalCost =
      totals.reduce(
        (sum: number, r: any) => sum + Number(r.metrics.cost_micros),
        0
      ) / 1_000_000;
    const totalConv = totals.reduce(
      (sum: number, r: any) => sum + Number(r.metrics.conversions),
      0
    );

    return {
      period: "LAST_30_DAYS",
      total_spend_usd: totalCost.toFixed(2),
      total_clicks: totals.reduce(
        (s: number, r: any) => s + Number(r.metrics.clicks),
        0
      ),
      total_conversions: totalConv.toFixed(1),
      avg_cpa_usd:
        totalConv > 0 ? (totalCost / totalConv).toFixed(2) : null,
      top_5_campaigns: top5.map((r: any) => ({
        name: r.campaign.name,
        spend_usd: (Number(r.metrics.cost_micros) / 1_000_000).toFixed(2),
        conv: r.metrics.conversions,
      })),
      campaign_count_by_type: types.reduce(
        (acc: Record<string, number>, r: any) => {
          const t = r.campaign.advertising_channel_type;
          acc[t] = (acc[t] || 0) + 1;
          return acc;
        },
        {}
      ),
    };
  },
};

Die 2 verbleibenden Tools (pull_report für Custom Exports und add_negative für bestätigte Mutationen) folgen demselben Muster. Das Repo github.com/steerads/mcp-google-ads-server enthält den vollständigen Code, plus 2 zusätzliche Tools (update_keyword_bid mit Confirm, list_audiences).

Die Unterscheidung Read-Only vs. Mutation verdient ein Wort. Die Tools search_campaigns, get_account_audit, pull_report sind durch Konstruktion sicher: Sie ändern den Kontostand nicht, können beliebig oft aufgerufen werden, und ihre Kosten sind auf API-Quota-Verbrauch begrenzt. Die Tools add_negative_keyword, update_keyword_bid, pause_campaign sind Mutatoren und erfordern zusätzliche Disziplin. Das dominante Muster, das wir anwenden, ist Double Opt-in: ein globales READ_ONLY_MODE=true Flag, das Mutationen serverseitig komplett deaktiviert, plus eine explizite Bestätigung, die vor jeder einzelnen Mutation vom LLM angefordert wird. Dokumentiert auf der Google Ads API Best Practices Seite, vermeidet dieser zweistufige Schutz versehentliche Mutationen in offenen Debug- oder Explorations-Sessions.

Google Ads OAuth-Authentifizierung in MCP

Google Ads OAuth folgt demselben Muster wie ein eigenständiges Python- oder Node.js-Skript: developer_token + refresh_token + login_customer_id. Die MCP-Besonderheit: Diese Credentials werden dem Server über das env der claude_desktop_config.json-Datei übergeben, beim Start des Prozesses geladen.

Um den initialen refresh_token zu generieren, ist es am einfachsten, das offizielle google-ads-python-Skript zu nutzen (Verfahren detailliert in unserem Python API Setup-Guide). Sobald der refresh_token generiert ist, ist er dauerhaft gültig (Google widerruft ihn selten, außer bei Passwortänderung oder manueller Widerrufung).

Der Auth-Flow im MCP-Server:

// src/auth-check.ts
import { getCustomer } from "./google-ads.js";

export async function validateCredentials() {
  const required = [
    "GOOGLE_ADS_DEVELOPER_TOKEN",
    "GOOGLE_ADS_CLIENT_ID",
    "GOOGLE_ADS_CLIENT_SECRET",
    "GOOGLE_ADS_REFRESH_TOKEN",
    "GOOGLE_ADS_LOGIN_CUSTOMER_ID",
  ];

  const missing = required.filter((k) => !process.env[k]);
  if (missing.length > 0) {
    throw new Error(
      `Missing required env vars: ${missing.join(", ")}. ` +
        `Check claude_desktop_config.json.`
    );
  }

  // Test query: verify credentials are valid
  try {
    const customer = getCustomer();
    const test = await customer.query("SELECT customer.id FROM customer LIMIT 1");
    if (!test || test.length === 0) {
      throw new Error("Empty response from API");
    }
    console.error(`[Auth] OK customer ${test[0].customer.id}`);
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    throw new Error(
      `Auth failed: ${msg}. Check refresh_token and login_customer_id.`
    );
  }
}

Rufen Sie validateCredentials() beim Server-Start auf (nach Transport-Init, vor dem Akzeptieren von Tool-Aufrufen). Wenn die Auth fehlschlägt, loggt der Server den Fehler nach stderr und beendet sich mit Code 1 — Claude Desktop sieht den Server als down und zeigt dem User den Fehler an.

Produktionssicherheit: Wenn Sie den MCP-Server auf einem geteilten Server deployen (HTTP/SSE-Modus), hardcoden Sie Creds NIEMALS im Klartext. Nutzen Sie einen Secret Manager (AWS Secrets Manager, GCP Secret Manager, HashiCorp Vault) und laden Sie Creds beim Start. Für den individuellen lokalen stdio-Modus ist die Klartext-claude_desktop_config.json akzeptabel, weil sie nicht committed ist und die Maschine per Definition vertrauenswürdig ist.

Anwendungsfälle: Audit, Optimierung, Reporting via konversationelles Claude

Sobald der MCP-Server installiert ist, ändert sich der Workflow radikal. Hier sind 5 Nutzungsmuster, die die PPC-Produktivität revolutionieren.

Muster 1 — Konversationelles Audit: "Audit mein Konto"

User: "Audit mein Google Ads Konto, was wirkt diese Woche merkwürdig?"

Claude ruft get_account_audit auf, erhält die KPIs und formuliert eine strukturierte Analyse: "In den letzten 30 Tagen haben Sie $49.750 für 247 Conversions ausgegeben, ein durchschnittlicher CPA von $201. Drei Aufmerksamkeitspunkte: Die Kampagne 'Brand Search US' macht 38 % der Ausgaben, aber nur 12 % der Conversions aus (überproportionaler CPA), die Kampagne 'PMax Generic' hat einen CPA von $453 vs. $159 bei Brand Search (fragwürdige Inkrementalität), und 4 Kampagnen haben einen CTR unter 2 %, was einen Asset-Refresh verdient."

Es ist das Audit, das Sie manuell in 30 Minuten gemacht hätten, in 8 Sekunden geliefert.

Muster 2 — Ad-hoc Deep Dive: "Warum ist der CPA gestern explodiert?"

User: "Der CPA in der Kampagne 'Search Generic US' hat sich gestern verdoppelt, was ist passiert?"

Claude verkettet mehrere Tool-Aufrufe: pull_report (CPC + CTR + Conv Rate gestern vs. LAST_7_DAYS), möglicherweise pull_search_terms (Search Query Report), möglicherweise pull_competitor_metrics (Impression Share). Synthese: "Der durchschnittliche CPC stieg von $1,32 auf $2,70 (+104 %) beim Keyword 'CRM software'. Der absolute Impression Share fiel von 65 % auf 32 % (-33 PP). Wahrscheinliche Ursache: ein neuer aggressiv bietender Wettbewerber. Empfehlung: Broad-Keyword-Matching auf generisches 'CRM' prüfen und ein Negative erwägen, um nur Phrase + Exact Match zu behalten."

Muster 3 — Wöchentliches Reporting: "Gib mir den Wochen-Digest"

User: "Erstelle den Wochenbericht für meine 3 größten Kampagnen."

Claude ruft pull_report 3-mal mit passenden Filtern auf, formatiert einen Markdown-Digest, den Sie in eine E-Mail oder Slack kopieren können. Schneller als ein Digest-Skript, anpassbarer als native Google Ads Reports.

Muster 4 — Mutationen mit Bestätigung: "Füge 'gratis' als Negative hinzu"

User: "Füge 'gratis' als Negative in der Kampagne 'Search Premium B2B' hinzu."

Claude ruft add_negative_keyword mit einem Confirm-Schritt auf: "Ich werde 'gratis' als Phrase-Match-Negative auf Kampagnenebene in 'Search Premium B2B' (ID 12345) hinzufügen. Bestätigen?". Nach positiver Antwort führt das Tool die Mutation aus und gibt den resource_name zurück. Schnellerer Workflow als das Navigieren der Google Ads UI, kontrollierter als ein automatisches Skript.

Muster 5 — Konto-übergreifende Synthese (Multi-Account)

User: "Vergleiche die Performance von US- und UK-Konto in diesem Monat."

Claude ruft get_account_audit zweimal auf (einmal pro customer_id), synthetisiert die Lücken: "Das US-Konto gibt 1,8× mehr aus als UK für 1,4× mehr Conversions, also ein um 28 % höherer CPA in US. Das CPA-Delta erklärt sich hauptsächlich durch einen höheren durchschnittlichen CPC in US (+34 %), gebunden an lokalen Wettbewerb, teilweise ausgeglichen durch einen besseren CTR (+8 PP)."

Für eine Agentur, die 10+ Konten auditiert, ist es ein Game Changer.

Über die fünf oben genannten Muster hinaus besteht eine fortgeschrittene Nutzung darin, mehrere MCP-Server in derselben Konversation zu verketten. Sie installieren parallel einen Google Ads MCP-Server, einen GA4 MCP-Server (Analytics), einen BigQuery MCP-Server und einen Slack MCP-Server. Claude kann dann verketten: Google Ads Daten ziehen, mit GA4-Events abgleichen, in BigQuery aggregieren und einen Digest auf Slack posten — alles in natürlicher Sprache. Laut den beobachteten Branchen wird dieses Multi-Server-Muster hauptsächlich in Growth-Teams adoptiert, die ihren Analytics-Stack bereits gereift haben; es erfordert Tool-Naming-Disziplin (Kollisionen zwischen Servern vermeiden) und Berechtigungs-Wachsamkeit (jeder Server hat seine eigenen Credentials, sodass der Autorisierungsumfang zwischen Servern wasserdicht bleibt).

Aktuelle Grenzen und MCP-Roadmap

MCP bleibt in Q1 2026 ein junges Protokoll (15 Monate nach Anthropics Spec), mit einem im Aufbau befindlichen Ökosystem und dokumentierten funktionalen Lücken. Das Protokoll glänzt im synchronen Konversationsmuster (ein Mensch stellt eine Frage, das LLM ruft Tools auf, der Server antwortet), bleibt aber bei asynchronen, Multi-Agent- oder Batch-Mustern begrenzt. Laut den beobachteten Branchen bleibt die MCP-Adoption in PPC unter technischen Power Usern konzentriert; die Verbreitung an nicht-technische PPC Manager wird auf eine 1-Klick-Installer-Abstraktionsschicht warten. Die fünf Grenzen unten sollten bekannt sein, bevor eine MCP-Schicht in Produktion gebracht wird.

Grenze 1 — Kein Scheduler. Ein MCP-Server kann nicht auf Cron laufen. Er führt nur Code aus, wenn Claude Desktop ihn aufruft. Für wiederkehrende Automatisierungen (stündliche Alerts, tägliche Reports) kombinieren Sie MCP + externes Cron (unabhängiges Python-Skript, das Insights via Webhook pusht). Siehe unseren n8n Google Ads Guide für Cron-Automatisierungen.

Grenze 2 — Keine reichhaltige UI. Claude Desktop zeigt Text und Markdown an. Für ein Chart, eine interaktive Tabelle, Drag-Drop ist MCP nicht das richtige Medium. Nur Text-First-Anwendungsfälle.

Grenze 3 — Kumulative Latenz. Jeder Tool-Aufruf fügt ~500 ms bis 2 s Latenz hinzu (LLM-Denken + Tool-Exec + LLM-Synthese). Eine Kette von 5 Tool-Aufrufen = 5 bis 10 Sekunden Wartezeit. Für einen PPC Manager, der an Instant-Dashboards gewöhnt ist, ist das eine Tempo-Änderung.

Grenze 4 — Zu viele Tools = schlechte LLM-Wahl. Über 12-15 Tools in einem einzigen Server beginnt Claude beim richtigen Tool zu zögern. Aufteilen in mehrere thematische MCP-Server.

Grenze 5 — Keine nativen Batch-Operationen. Ein Tool-Aufruf = eine Operation. Für 1.000 Mutationen sind 1.000 Tool-Aufrufe nicht tragfähig. Behalten Sie Bulk-Operationen auf der Standalone-Skript-Seite, exponieren Sie nur unitäre Aktionen via MCP.

Die MCP-Roadmap (wie von Anthropic in Q4 2025 angekündigt) plant für 2026: native Scheduling-Unterstützung auf MCP-Seite (um Grenze 1 zu eliminieren), ein besser indiziertes offizielles Verzeichnis mit Bewertungen (Server-Qualität), reifere HTTP/SSE-Transports für Team-Setups und eine Observability-Schicht (Tool-Call-Telemetrie, Debugging-UI). Folgen Sie der offiziellen MCP-Dokumentation für Updates.

Für Konten, die Google Ads Steering mit einer Managed-AI-Schicht industrialisieren möchten (ohne ihren eigenen MCP-Server zu codieren), deckt unser Auto-Optimization-Modul Audit-, Monitoring- und Alerting-Anwendungsfälle im Managed-Modus mit dedizierter UI ab — siehe auch unsere Google Ads Audit-Checkliste für die Audit-Basis, die jeder AI-Schicht vorausgehen sollte. Für andere Automatisierungsbausteine siehe unseren Python API Setup-Guide und unseren n8n Flows Guide.

Für offizielle MCP-Ressourcen siehe modelcontextprotocol.io (Protokoll-Spezifikation) und Claude MCP Dokumentation (Anthropic-Guides).

Quellen

Offizielle Quellen für diesen Leitfaden:

• schema.org
• blog.google
• anthropic.com
• platform.openai.com

FAQ