The Google Ads API Is No Longer Just for Developers

I would never have made a video about the Google Ads API a couple of years ago. I’m a marketer, not a developer. The API was something that was really only accessible to engineering teams, and you would never have any marketers talking about it.

That’s completely different now. I use the Google Ads API every single day for my own accounts, for the software I’m building at PPC.io, and for agencies I consult with. I’m not the most technical person in the world, but I’m pulling data from over 100 accounts across 4 manager accounts, and I’m not writing any code myself.

Three specific changes in the last six months opened the floodgates. If you manage Google Ads professionally, this matters.

What Is the Google Ads API (And Why Isn’t the UI Enough)?

The Google Ads API is not the interface you see when you log into Google Ads. It’s the raw data pipeline underneath it. Every metric, every dimension, every report that exists in Google Ads is accessible through this API. We’re talking 181 queryable resources in the latest version alone.

Here’s the practical difference. In the Google Ads UI, you’re clicking through one screen at a time. You can see campaign performance, then you click into an ad group, then you click into keywords, then you switch to search terms. If you’re an agency managing 20 or 30 accounts, you’re doing that across every single one. That’s the human brain trying to process information page by page.

The API lets you pull all of it at once. And when you connect that to an AI model, you can ask questions in plain English and get answers back in seconds.

	Google Ads UI	Google Ads API
Data access	One screen at a time	Everything at once
Accounts	Switch between them manually	Query all from one connection
Analysis	You do the thinking	AI does the analysis
Speed	Minutes per account	Seconds per account
Automation	Manual, repetitive	Repeatable, scriptable
Custom reports	Limited to built-in views	Build anything you want

Google has their own query language called GAQL (Google Ads Query Language) . It reads almost like English. Here’s what a real query looks like:

SELECT
  campaign.name,
  campaign.status,
  metrics.cost_micros,
  metrics.clicks,
  metrics.conversions,
  metrics.search_impression_share
FROM campaign
WHERE campaign.status = 'ENABLED'
  AND segments.date DURING LAST_30_DAYS
ORDER BY metrics.cost_micros DESC

That single query pulls every active campaign with spend, clicks, conversions, and impression share for the last 30 days, sorted by highest spend first. In the UI, you’d need to navigate to the campaigns tab, set the date range, add the impression share column, and then export. And that’s just one account.

With AI, you don’t even need to learn GAQL . You say “show me all campaigns where I’m spending money but getting no conversions” and the AI writes that query for you.

Three Changes That Opened the Floodgates

1. Explorer Access Tier (October 2025)

This was the big one. Google released the Explorer access tier, and it removed the single biggest barrier to the API: the application process.

Previously, you had to apply for a developer token, write a detailed explanation of your use case, and wait for Google to review it. That process alone stopped every marketer who wasn’t working with a dedicated dev team. Now, if you have an MCC (manager account), you get instant production access. No application. No review. No waiting.

Access Tier	Daily Operations	Application Required	Best For
Explorer	2,880	No (instant)	Agencies, in-house teams getting started
Basic	15,000	Yes (~2 business days)	Growing tools, more accounts
Standard	Unlimited	Yes (~10 business days)	SaaS products, large-scale tools

2,880 operations per day is plenty for most agencies. I run audits, pull search term reports, analyze quality scores, and check budget pacing across multiple accounts, and I rarely hit that limit.

The demand was massive. By February 2026, Google publicly acknowledged a backlog in processing Basic and Standard access applications because so many people were upgrading from Explorer. They had to bring on additional reviewers. That tells you everything about how much interest there is.

2. Official MCP Server (October 2025)

On October 7th, Google open-sourced an official MCP server for the API. MCP (Model Context Protocol) is the standard that lets AI tools like Claude and Gemini talk directly to external services.

The Google Ads MCP exposes two tools: search (execute any GAQL query) and list_accessible_customers (see all accounts you can access). It’s intentionally read-only. You can pull any data you want, but you can’t modify bids, pause campaigns, or create ads through it. That’s a deliberate safety choice from Google.

Here’s what this means practically: you open Claude, connect the MCP, and start asking questions. “What’s my impression share on branded campaigns?” “Which ad groups have a CPA above $50?” “Show me search terms with more than $100 spend and zero conversions.” The MCP translates your question into a GAQL query, hits the API, and returns the data.

If you have just an individual Google Ads account (not a manager account), the MCP is your best starting point. It’s a 5-minute setup with no code involved. If you have an MCC and want full control, including write access, direct API integration through Claude Code is the more powerful path.

3. The Developer Assistant

Google also released the Google Ads API Developer Assistant. Built on Gemini, it’s live on Google’s public GitHub and it’s genuinely useful.

What can it actually do? It answers natural language questions about the API, generates valid GAQL queries from plain English descriptions, writes executable Python scripts, runs those scripts directly against the API, exports results to CSV, and validates your queries before they hit production. Version 2.0 (February 2026) upgraded it from a code generation tool into what Google calls a “proactive troubleshooting and automation partner.”

If you’re a developer at an agency building internal tools, this cuts your ramp-up time dramatically. Instead of reading through hundreds of pages of documentation trying to figure out which of the 181 resources you need and which fields are compatible, you just ask.

What Can You Actually DO With the API?

This is where most content about the Google Ads API falls short. Everyone says “you can pull data and make changes.” That’s useless. Let me show you the specific things I use the API for, with real queries.

Search Term Waste Detection

This is probably my most-used workflow. One query pulls every search term that got clicks, sorted by spend:

SELECT
  campaign.name,
  search_term_view.search_term,
  metrics.cost_micros,
  metrics.conversions,
  metrics.clicks,
  metrics.impressions
FROM search_term_view
WHERE campaign.status = 'ENABLED'
  AND segments.date DURING LAST_90_DAYS
  AND metrics.clicks >= 1
ORDER BY metrics.cost_micros DESC
LIMIT 1000

When I ran this on one account, the results were immediate. “scrape linkedin” had $96.81 in spend with zero conversions across 33 clicks. “scraper linkedin” was another $72.75 wasted. “linkedin post date extractor” burned $65.53 on 29 clicks with nothing to show for it. These are search terms that would take you ages to find clicking through the UI, but the API surfaces them in seconds.

I then feed these results into an AI model and ask it to cluster the waste into themes and suggest negative keywords. The whole process takes maybe 2 minutes instead of an hour.

Quality Score Audits at Scale

Quality scores are buried in the Google Ads UI. Through the API, I pull all three quality score components for every keyword in an account with one query:

SELECT
  campaign.name,
  ad_group.name,
  ad_group_criterion.keyword.text,
  ad_group_criterion.quality_info.quality_score,
  ad_group_criterion.quality_info.creative_quality_score,
  ad_group_criterion.quality_info.post_click_quality_score,
  ad_group_criterion.quality_info.search_predicted_ctr,
  metrics.cost_micros,
  metrics.conversions
FROM keyword_view
WHERE ad_group_criterion.status = 'ENABLED'
  AND campaign.status = 'ENABLED'
  AND segments.date DURING LAST_90_DAYS
  AND metrics.impressions > 50
ORDER BY metrics.cost_micros DESC
LIMIT 500

This tells me exactly which keywords have a landing page problem versus an ad relevance problem versus a CTR problem. That’s the difference between “your quality scores are low” (useless) and “these 12 keywords have below-average landing page experience and they’re costing you $4,200/month” (actionable).

Impression Share Analysis

Want to know where you’re losing visibility? Three metrics tell the whole story:

• search_impression_share - what percentage of eligible impressions you’re getting
• search_budget_lost_impression_share - impressions lost because your budget ran out
• search_rank_lost_impression_share - impressions lost because your ad rank was too low

When I pull these at the campaign level, patterns jump out immediately. If budget-lost impression share is high, you’re capping your own growth. If rank-lost is high, you need better quality scores or higher bids. These numbers exist in the UI too, but pulling them across 20 accounts at once is where the API shines.

Cross-Account Portfolio Dashboards

If you manage multiple accounts (and most agencies do), the API is transformative. One connection to your MCC, and you can query every child account:

SELECT
  customer_client.id,
  customer_client.descriptive_name,
  customer_client.status
FROM customer_client
WHERE customer_client.status = 'ENABLED'
  AND customer_client.manager = false

That lists every account under your MCC. Then you loop through each one pulling campaign performance, and suddenly you have a complete portfolio view. Which accounts are overspending? Which have tanking conversion rates? Which have impression share problems? I use this every Monday morning to prioritize my week. It replaces the 45-minute ritual of logging into each account individually.

Landing Page Performance

The API can show you exactly which landing pages are getting traffic and how they’re converting:

SELECT
  landing_page_view.unexpanded_final_url,
  metrics.clicks,
  metrics.cost_micros,
  metrics.conversions
FROM landing_page_view
WHERE segments.date DURING LAST_90_DAYS
  AND metrics.clicks >= 10
ORDER BY metrics.clicks DESC
LIMIT 100

I pair this with browser automation. The API tells me which pages get traffic. Then I use Playwright to actually visit each page, screenshot it, and check for message match with the ad copy. That workflow caught a problem for one client where their Scotland traffic was landing on the homepage instead of a dedicated location page. Nobody had noticed for months. That’s the kind of insight that actually moves the needle.

What Else?

I’m only scratching the surface. Here’s what’s possible across those 181 resources:

• Ad copy performance - Pull every RSA headline and description with individual asset performance scores
• Device and geographic breakdowns - See exactly how mobile vs desktop vs tablet performs by campaign, or which cities are converting
• Budget pacing - Compare daily spend against budget allocations programmatically
• Auction insights - Pull competitive data showing who you’re competing against and how often you win
• Change history - Track every change made to an account (useful for audits and finding wasted spend )
• Performance Max transparency - New in v23: break down PMax performance by network (Search, YouTube, Display, Gmail, Maps, Discover) for the first time via API
• Shopping product data - Query product-level performance for ecommerce accounts

Google Is Building in Public

This is the part that surprised me most. Google is doing something I haven’t seen from any other ad platform.

They launched a public Discord channel (the #ads-api-ai-tools channel on Google Advertising Community). I’m in there. There are active conversations about what people are building, troubleshooting API issues in real-time, and feature requests going directly to the team.

They started Ads DevCast in March 2026, a bi-weekly vodcast hosted by Developer Relations Engineer Cory Liseno. It covers technical deep dives into the API, interviews with the engineers building these tools, and discussions across Google Ads, Analytics, and Display & Video 360.

They shifted to monthly API releases. Version 23 landed January 28, 2026, followed by v23.1 in February and v23.2 shortly after. The previous cadence was quarterly. That’s a 3x increase in release velocity.

And everything is public. The MCP server is open-source on GitHub. The Developer Assistant is open-source on GitHub. The release notes are detailed and published immediately. It feels like a build-in-public approach, and it’s working. The token application backlog proves there’s real demand.

Compare that to other platforms. Amazon Ads added an official MCP server, which is good. Meta has only third-party MCP servers, and they’ve been banning accounts that use the API to push low-quality AI content at scale. Nobody else is leaning into this the way Google is.

Live Demo: AI Talking Directly to Your Google Ads

Let me walk you through what this actually looks like in practice. I sit inside Claude Code (which runs inside VS Code), and I have a direct connection to the Google Ads API through Python.

I prompted it: “I want you to use the Google Ads API to investigate my Google Ads account. I want to explore wasteful keywords. Maybe there are keywords I should be negating.”

Here’s what happened. Claude wrote a GAQL query to pull the last 90 days of search term data. It returned the top 1,000 terms by spend. It identified clusters of irrelevant terms. “scrape linkedin” and its variants alone had burned through $235 with zero conversions. Terms like “linkedin post date extractor” were clearly wrong-intent traffic.

Then Claude asked: “Do you want me to add these as negative keywords directly? I have write access to this account. I can add all of them, just the top six, or a custom selection.”

That’s the moment it clicks. You’re not just looking at a report. You’re having a conversation with your account data, and the AI can act on what it finds. One prompt replaced 30-45 minutes of manual search term review, Excel filtering, and negative keyword list building.

The whole Python connection pattern is straightforward. You initialize a client with your credentials, point it at your MCC, and run GAQL queries against any child account:

from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_env()
ga_service = client.get_service("GoogleAdsService")

response = ga_service.search(
    customer_id="6385680446",
    query="""
        SELECT campaign.name, metrics.clicks, metrics.cost_micros
        FROM campaign
        WHERE segments.date DURING LAST_7_DAYS
        ORDER BY metrics.cost_micros DESC
    """
)

for row in response:
    spend = row.metrics.cost_micros / 1_000_000
    print(f"{row.campaign.name}: {row.metrics.clicks} clicks, ${spend:.2f}")

You don’t need to understand Python. You tell Claude Code what you want, and it writes and runs the code for you. That’s the whole point.

Agency Case Study: Lemonade IO

One of our consulting clients, Lemonade IO, is a growth marketing agency that’s gone deep on the API. They’re not just pulling data. They’ve built a complete workflow.

They have a skill inside Claude that says: query the Google Ads API, find all the information you need from the account, and generate a report in our brand style. The output matches their agency branding. Their clients receive something polished and readable, not a raw data dump.

They’re using it for three things:

1. New client sales audits - Connect a prospect’s account, run the audit skill, generate a branded report showing exactly where the opportunities are. Turns a multi-day process into a same-day deliverable.
2. Wasted spend detection - Weekly search term analysis across all client accounts, surfacing waste automatically instead of someone manually reviewing each one.
3. Ongoing client reporting - Monthly performance reports that pull live data, analyze trends, and present findings in language clients actually understand.

This is saving their team hours per client, per month. It’s not theoretical. It’s running in production at a real agency, right now. And the point is: they didn’t need a dev team to build this. They built it with Claude Code and the Google Ads API.

For agencies thinking about building their own internal tools, this is the playbook. The API gives you the data. AI gives you the analysis. Skills make it repeatable. That combination is what lets you scale an agency without hiring .

Security and Honest Limitations

I tell every agency I consult with the same thing: the API is powerful, but respect it.

Your developer token is the keys to the kingdom. If you’re an agency, that token gives access to every client account under your MCC. Store your credentials as environment variables, never in code files. Don’t share them over Slack or email. Treat them like your bank login.

Start read-only. Always. Pull reports, run audits, analyze data. Get comfortable with what the API returns before you ever enable write operations. The official MCP server is read-only by design, and that’s smart.

AI makes mistakes. I’ve seen Claude write a query with the wrong date range. I’ve seen it misinterpret a metric (cost_micros needs to be divided by 1,000,000 to get actual currency). Always review the output. Never auto-execute changes to a client account without human review.

Rate limits are real. Explorer tier gives you 2,880 operations per day. If you’re running complex audits across dozens of accounts, you can hit that. For very large agencies, you’ll need to upgrade to Basic (15,000/day) or Standard (unlimited).

The application backlog is real too. As of February 2026, Google acknowledged significant delays processing Basic and Standard access applications. If you need higher access, apply early.

Cloud-managed access is coming. Google is piloting a system where API access is managed through your Google Cloud organization instead of developer tokens. No more passing a token header in every request. It’s in closed beta now with no public launch date, but it’s the direction they’re heading.

How to Get Access: Which Path Is Right for You?

There are three paths depending on your setup. Here’s how to decide.

Path 1: Google Ads MCP (5 minutes, no code)

Best for: Individual accounts, quick exploration, non-technical users.

You connect the Google Ads MCP to Claude or another AI tool. Read-only access. No coding. You’re chatting with your data within minutes. If you’re not sure whether the API is useful for you, start here.

Path 2: Direct API via Claude Code (under an hour)

Best for: Agencies with MCC accounts, power users, anyone who wants full control.

This is what I use daily. You set up a Google Cloud project, get OAuth credentials, generate a refresh token, and connect it through Claude Code . Full read and write access. You can build reusable skills , automate weekly audits, and run complex multi-account workflows. The setup is a one-time investment.

1. Go to ads.google.com, navigate to API Center
2. Set up a Google Cloud project and enable the Google Ads API
3. Create OAuth credentials (Desktop app type)
4. Generate your refresh token (Claude Code can help you do this)
5. Store credentials as environment variables
6. Test the connection by pulling your campaign names

The OAuth setup is the annoying part. You’re going through Google Cloud Console, creating credentials, configuring consent screens. But you do it once and it works forever.

Path 3: Build a SaaS Product (weeks to months)

Best for: Developers building tools for other advertisers.

If you’re building a product that other agencies or advertisers will use, you’ll need Standard access (unlimited operations, requires application). Google will want to understand your business model and how your tool helps advertisers. The Developer Assistant on GitHub is a huge accelerator for this path.

	MCP	Direct API	SaaS Product
Setup time	5 minutes	Under 1 hour	Weeks+
Technical skill	None	Low (AI helps)	High
Access type	Read-only	Read + Write	Read + Write
Best for	Exploring	Daily workflows	Building products
Accounts	Individual or MCC	MCC recommended	Standard access required

What We’re Building at PPC.io

The Google Ads API is incredible infrastructure. But not everyone wants to set up OAuth credentials and configure Python environments.

That’s what we’re building at PPC.io. Pre-built AI agents that connect to your Google Ads account through the API. Audit tools, reporting skills , search term analysis, ad copy optimization. All the capabilities I’ve shown in this article, packaged into a clean interface.

You can also build your own tools on the platform. “This is how I audit my clients. Go connect to the API, pull the data I need, and create an audit in the style I already use.” Custom skills, repeatable workflows, at scale.

The API opened the door. We’re just making it easier to walk through.