Connect Google Ads to ChatGPT: Manage Campaigns and GAQL Reports

If you need to connect Google Ads to ChatGPT to automate campaign creation, run complex performance reports, or extract keyword forecasting data, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and the highly specific architecture of the Google Ads API.

If your team uses Claude, check out our guide on connecting Google Ads to Claude or explore our broader architectural overview on connecting Google Ads to AI Agents.

Giving a Large Language Model (LLM) read and write access to a platform that spends real money is a massive engineering challenge. You have to handle complex relational data payloads, map dynamic resources to MCP tool definitions, and deal with deeply nested mutation operations. Every time a developer wants to query a new segment or metric, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Google Ads, connect it natively to ChatGPT, and execute complex ad workflows using natural language.

The Engineering Reality of the Google Ads API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against the Google Ads API is exceptionally painful.

If you decide to build a custom MCP server for Google Ads, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with this specific API:

The GAQL Abstraction Layer

The Google Ads API relies heavily on the Google Ads Query Language (GAQL). Instead of hitting a simple /campaigns endpoint, clients submit string-based GAQL queries to a search endpoint. If an LLM needs to query campaign performance, it must know exactly how to structure a SELECT statement, which metrics are compatible with which resources, and which segments can be grouped together. Building an MCP server means either writing dozens of hard-coded query templates or teaching the LLM the entire GAQL specification. Truto solves this by exposing structured search and search-stream endpoints alongside targeted list methods, allowing the LLM to query data without hallucinating incompatible field combinations.

Batch Mutations and Resource Names

Google Ads uses a highly specific mutation pattern. You do not simply POST a JSON object to create an ad group. You must submit an array of operations (creates, updates, removes), and each operation requires a perfectly formatted resource_name (e.g., customers/123/campaigns/456). Translating an LLM's natural language request into a valid batch mutation payload requires strict schema validation. If your MCP server lacks comprehensive JSON Schemas for the request body, the LLM will fail to format the operations correctly, resulting in rejected payloads.

Nested Entity Relationships

Creating an ad isn't a single operation. A standard workflow requires querying the customer ID, identifying the target campaign, locating the ad group, and finally mutating an ad_group_ad resource. This involves navigating deep hierarchies. Your MCP server must expose tools that allow the LLM to traverse this hierarchy step-by-step, maintaining context of parent IDs throughout the conversation.

How to Generate a Google Ads MCP Server with Truto

Instead of building and maintaining a custom translation layer, Truto dynamically derives MCP tool definitions from the integration's resource schema and documentation. You can generate a Google Ads MCP server using either the Truto UI or the API.

Method 1: Via the Truto Dashboard

For teams who prefer visual configuration, the Truto dashboard provides a one-click generation flow.

1. Log into your Truto environment and navigate to the Integrated Accounts section.
2. Select your connected Google Ads account.
3. Click the MCP Servers tab in the account details view.
4. Click Create MCP Server.
5. Configure your server by selecting allowed methods (e.g., read, write) and tags (e.g., campaigns, budgets) to constrain what the LLM can access.
6. Copy the generated MCP server URL. This single URL handles routing, schema delivery, and authentication.

Method 2: Via the Truto API

For developers orchestrating agent infrastructure programmatically, you can generate an MCP server via a single API call. This scopes the server to a specific Google Ads connection and applies filters to limit the exposed tools.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Google Ads MCP for ChatGPT",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["campaigns", "ads", "keyword_plan_ideas"]
    }
  }'

The response contains the url field (e.g., https://api.truto.one/mcp/<secure_token>). This URL is fully self-contained. The embedded token securely maps the request to the correct tenant, environment, and underlying Google Ads credentials.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can connect it to ChatGPT. The platform provides two primary methods for establishing this connection depending on your deployment model.

Method 1: Via the ChatGPT UI (Custom Connectors)

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education accounts with Developer Mode enabled, you can add the server directly via the interface.

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is toggled on.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: Enter a descriptive name (e.g., "Google Ads - Truto").
5. Server URL: Paste your Truto MCP URL.
6. Click Add or Save.

ChatGPT will immediately ping the server's initialize endpoint, download the Google Ads schemas, and populate its context window with the available tools.

Method 2: Via Manual Configuration (Local / Custom Agents)

If you are running a custom agent framework locally or deploying your own instance of an LLM client that supports the MCP specification, you can configure the connection manually. Truto MCP servers support the Server-Sent Events (SSE) transport protocol over standard HTTP.

Create a configuration file (e.g., mcp-config.json) for your agent:

{
  "mcpServers": {
    "google_ads": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your_secure_token>"
      ]
    }
  }
}

This configuration instructs the MCP client to proxy the JSON-RPC traffic through the standard SSE transport, allowing your local environment to interact seamlessly with the remote Truto infrastructure.

Hero Tools for Google Ads

Truto automatically translates hundreds of Google Ads API methods into structured LLM tools. Here are six high-leverage hero tools that unlock advanced ad operations and reporting.

google_ads_google_ads_search

Executes raw Google Ads Query Language (GAQL) queries against the connected account. This is the ultimate read tool, allowing the LLM to pull campaigns, ad groups, metrics, and segments in a single operation. It supports all 188 reportable resources and handles pagination via page_token.

"Write a GAQL query to fetch the id, name, and status of all campaigns that had more than 100 clicks yesterday, and execute the search."

create_a_google_ads_campaign

Creates, updates, or removes campaigns by accepting a batch of mutate operations. The LLM must construct a payload defining the campaign's name, advertising channel type, status, bidding strategy, and campaign budget resource name.

"Create a new Search campaign named 'Q3 Product Launch' set to PAUSED status. Use manual CPC bidding and link it to the budget resource customers/1234567890/campaignBudgets/987654321."

get_single_google_ads_campaign_budget_by_id

Retrieves the details of a specific campaign budget. Because budgets in Google Ads exist as independent resources that campaigns link to, this tool is critical for inspecting financial constraints before making campaign adjustments.

"Look up the details for campaign budget ID 987654321 and tell me if its delivery method is set to accelerated or standard."

google_ads_keyword_plan_ideas_generate_keyword_ideas

Generates keyword suggestions and historical search volume metrics. The LLM can pass in a seed keyword or a URL, and the tool returns data directly from Google's keyword planner, perfect for automated SEO and SEM research.

"Generate keyword ideas based on the seed term 'enterprise saas integrations' and summarize the top 5 suggestions by historical search volume."

create_a_google_ads_ad_group_ad

Creates, updates, or removes ads within specific ad groups. The LLM must supply the ad_group resource name and the ad format payload (e.g., responsive_search_ad with arrays of headlines and descriptions).

"Create a new responsive search ad in ad group customers/123/adGroups/456. Write 3 compelling headlines about 'zero downtime migrations' and set the final URL to our pricing page."

google_ads_campaign_budgets_mutate

Submits mutate operations specifically for campaign budgets. This allows the LLM to dynamically increase or decrease daily budgets across the account based on performance triggers.

"Increase the amount of campaign budget customers/123/campaignBudgets/456 by 20% to capitalize on recent high conversion rates."

To view the complete inventory of available endpoints and their exact schema parameters, visit the Google Ads integration page.

Workflows in Action

Exposing individual tools is just the foundation. The real power of connecting Google Ads to ChatGPT via MCP is the ability to chain operations together to execute complex, multi-step workflows. Here are two real-world scenarios.

Workflow 1: AI-Driven Keyword Expansion and Campaign Creation

Persona: Performance Marketer looking to launch a new product category.

"I need to launch a new search campaign for 'unified api solutions'. First, generate keyword ideas for this term. Pick the top 5 by search volume. Then, create a new daily budget of $50, create a new campaign linked to that budget, create an ad group, and finally, add those 5 keywords as exact match criteria to the ad group."

Execution Steps:

1. google_ads_keyword_plan_ideas_generate_keyword_ideas: ChatGPT requests suggestions for "unified api solutions" and parses the historical metrics.
2. google_ads_campaign_budgets_mutate: The LLM constructs a create operation for a new campaign_budget with the specified amount and returns the new resource name.
3. create_a_google_ads_campaign: Using the budget resource name, the LLM creates a new Search campaign and captures its resource name.
4. create_a_google_ads_ad_group: The LLM creates an ad group attached to the new campaign.
5. google_ads_ad_group_criteria_mutate: Finally, the LLM loops through the top 5 keywords, generating create operations for ad_group_criterion entities with exact_match configurations.

sequenceDiagram
    participant ChatGPT as ChatGPT
    participant TrutoMCP as Truto MCP Server
    participant GAds as Google Ads API

    ChatGPT->>TrutoMCP: Call generate_keyword_ideas
    TrutoMCP->>GAds: Request forecasts
    GAds-->>TrutoMCP: Return top keywords
    TrutoMCP-->>ChatGPT: JSON metrics
    ChatGPT->>TrutoMCP: Call mutate_budgets
    TrutoMCP->>GAds: Create $50 budget
    GAds-->>TrutoMCP: Return budget ID
    TrutoMCP-->>ChatGPT: Resource Name
    ChatGPT->>TrutoMCP: Call create_campaign
    TrutoMCP->>GAds: Execute campaign creation
    GAds-->>TrutoMCP: Return campaign ID
    TrutoMCP-->>ChatGPT: Success confirmation

Workflow 2: Automated Budget Reallocation Based on CPA

Persona: AdOps Manager performing daily optimizations.

"Run a GAQL query to find all campaigns that had a Cost Per Acquisition (CPA) higher than $100 over the last 7 days. For any campaign that matches, reduce its daily budget by 15%."

Execution Steps:

1. google_ads_google_ads_search: ChatGPT writes a GAQL query selecting campaign.resource_name, campaign_budget.resource_name, and metrics.cost_per_conversion where segments.date is within the last 7 days.
2. Data Analysis: The LLM parses the returned JSON rows, identifying campaigns exceeding the $100 CPA threshold.
3. google_ads_campaign_budgets_mutate: For each offending campaign, the LLM calculates the new reduced budget amount and issues an update operation with the correct update_mask applied to the specific budget resource names.

Security, Access Control, and Rate Limits

Giving an AI agent access to an active Google Ads account requires strict governance. Truto MCP servers enforce security at the infrastructure layer, ensuring your underlying data remains protected.

• Method Filtering: Restrict servers to specific operations. By setting methods: ["read"], you guarantee the LLM can only run reports and query data, removing any risk of accidental budget changes or ad deletions.
• Tag Filtering: Group operations by domain. Setting tags: ["campaigns", "budgets"] ensures the LLM cannot access billing data, user management, or audience insights.
• Additional Authentication: By setting require_api_token_auth: true, the MCP client must supply a valid Truto API token in the Authorization header. This adds a secondary authentication gate beyond the secure URL.
• Automatic Expiry: Set an expires_at timestamp to create temporary MCP servers. Once the time elapses, the server infrastructure is automatically purged, instantly revoking the LLM's access.

A Critical Note on Rate Limits: Truto operates as a transparent integration layer. We do not retry, throttle, or apply backoff logic on rate limit errors. If the Google Ads API returns an HTTP 429 error, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The LLM client or agent orchestration framework is strictly responsible for implementing its own retry and backoff strategies.

Moving Forward with Agentic Ad Operations

Connecting Google Ads to ChatGPT via an MCP server transitions your team from clicking through complex UI dashboards to managing ad spend via natural language. By leveraging Truto to generate the MCP infrastructure, you bypass the massive engineering burden of maintaining GAQL schemas, parsing batch mutations, and handling complex API authentication.

Your engineers can stop building bespoke integration tooling, and your marketing teams can start deploying autonomous agents to analyze performance, optimize bids, and generate campaigns at scale.