Free, production-tested Google Ads scripts for automation, monitoring and reporting — ready to copy-paste into your account.
Accounts rot quietly. An ad gets disapproved, an ad group loses its last ad, conversion tracking silently breaks, a campaign starves on budget — each one invisible in the day-to-day until it has cost real money. This script is the smoke detector: a battery of health checks over the whole account, on a schedule, with one digest email of everything it finds. It changes nothing.
The single-account edition of the [MCC Spend Anomaly Detector](../mcc-spend-anomaly-detector/) — for when you don't manage the account through an MCC, or a client runs the script in their own account. Same statistical engine, plus one thing the MCC edition doesn't do: **per-campaign monitoring**, which catches the incident the account total hides — one campaign dies, the others keep spending, and the total still looks normal.
Bid adjustments by hour and day are guesses until you've seen the heatmap: which hours spend money, which hours convert, and — the cell that matters — which hours spend *without* converting. Google's UI gives you hourly OR daily breakdowns; the 7×24 picture you actually schedule around isn't a report you can click to. This script builds it.
Google can change your accounts without asking: with auto-apply recommendations enabled — sometimes without anyone remembering having enabled them — keywords appear, budgets shift, targeting expands. The change history records it all, attributed to **Recommendations Auto-Apply**, but nobody reads change history daily across an MCC. This script does, and emails one morning digest — so nothing changes in your accounts without a human knowing.
Two campaign states quietly waste money: chronically capped (budget runs out daily, delivery throttled, CPCs drift up) and chronically idle (budget sits unused while a capped sibling starves). Both are invisible on any single day — they are patterns. This script measures each enabled campaign's average daily spend against its daily budget over the window and reports both tails.
"Who changed that?" is the first question after every performance jump — and the change history screen answers it one hunt at a time. This script turns it into a push: every morning, one email with yesterday's account changes — who, what resource, which operation — grouped by user.
Unless you deliberately bid on competitor names, searches like "competitor-brand + your product" are expensive clicks with terrible intent — the searcher wants them, not you. Those queries slip in through phrase and broad matching, one impression at a time, across every ad group, and negating them by hand never keeps up. This script keeps up: every search term containing a competitor brand becomes a negative exact keyword in the ad group that matched it.
When the same search query serves from two ad groups, they compete against each other: the query's performance data splits, the less relevant ad often wins the auction, and neither ad group accumulates clean history. This script routes every shared query to a single owner — the ad group whose trigger keyword is most similar to the query — and fences it off everywhere else with a negative exact keyword.
Mobile clicks are not desktop clicks: on many accounts one device converts at half the cost of the other, and campaign averages hide it. This script breaks every campaign down by device, compares each device's cost/conv against the campaign's own average, and suggests the bid adjustment that would price the gap — as a report, not a change.
A branded campaign's DSA ad group has one job: catch brand-related queries the keywords missed. But DSA doesn't know your brand list — it matches on pages, so generic queries leak in and spend the branded budget on traffic that belongs elsewhere. This script fences the DSA ad groups of your targeted campaigns to an allowlist: search terms that do **not** contain any allowed term become negative exact keywords in the ad group that matched them.
Dynamic Search Ads are great at finding queries you didn't think of — and just as good at quietly taking over queries your keyword campaigns already serve. When both serve the same term you pay twice to compete with yourself, and the term's data splits across campaigns. This script fences the DSA side automatically, with one pragmatic exception: **if DSA gets the term at a cheaper CPC, DSA keeps it.**
The same keyword in two ad groups splits its own history: two Quality Scores, two ad tests, Google picking the entry point per auction. Duplicates accumulate through restructures and bulk uploads, and nobody audits for them by hand. This script finds every keyword text + match type living in more than one enabled ad group, compares the copies side by side, and recommends the survivor.
The classic alpha/beta search structure mirrors every campaign twice: an Exact campaign for control and a Phrase campaign for discovery. It works — until the mirrors drift. A keyword added to the Exact side never reaches the Phrase side, ad groups fall out of parity, and coverage quietly develops holes. This script keeps the two sides in sync automatically, both directions, every run.
In a mirrored Exact/Phrase (alpha/beta) structure the Phrase campaign's job is discovery — finding new queries. But without fencing, phrase keywords also match the exact terms your Exact campaign already owns, splitting traffic between the two and blurring your per-term data. This script builds the fence: every serving keyword in an Exact campaign becomes a negative exact keyword in its mirrored Phrase ad group, so exact traffic flows only through the Exact side.
Location decisions age: the region that earned its +20% adjustment two years ago may be your worst performer today. This script aggregates performance by the user's actual country, ranks locations by spend, flags the ones converting far worse than the account average, and writes the full picture to a spreadsheet.
Impression share explains the other metrics: conversions dropped because you lost the auction, not because the ads got worse. But Google shows IS as a snapshot — the trend never accumulates anywhere. This script accumulates it: every run appends each search campaign's IS and its two loss components to a history spreadsheet, and alerts when a campaign drops sharply against its own trailing average.
Part of the [DSA Layering playbook](../../docs/DSA-LAYERING.md): a DSA ad group without ads serves nothing, and writing DSA descriptions per campaign by hand doesn't scale. It doesn't need to — the campaign's responsive search ads already carry proven copy. This script fills every inner DSA ad group with dynamic search ads built from the campaign's own RSA descriptions.
Part of the [DSA Layering playbook](../../docs/DSA-LAYERING.md): the inner DSA ad group inside each keyword campaign earns its keep on queries the keywords *don't* cover. When a query serves from both the keyword ad groups and the inner DSA, the DSA is cannibalising, not catching. This script fences it — with two deliberate exceptions where the DSA keeps the term.
Part of the [DSA Layering playbook](../../docs/DSA-LAYERING.md): every keyword campaign carries one **inner DSA ad group** targeting exactly the landing pages the campaign's keywords advertise — catching the campaign's long-tail queries with the campaign's own budget, geo targeting and bid strategy. That only works while the DSA ad group's webpage targets mirror the campaign's real landing pages, and keywords change weekly. This script keeps the mirror, automatically.
Accounts with a catalog dimension — brands, cities, models, materials — need the same keyword pattern repeated dozens or hundreds of times: `buy {brand} shoes` for every brand you carry, each pointing at the brand's landing page. Building that by hand is slow; keeping it in sync as the catalog changes is worse. This script does the expansion: mark template keywords with a label, declare your value list once, and every template × value combination becomes a real keyword with the placeholder substituted in both the text and the final URL.
The ad is perfect, the bid is right — and the landing page is a 404. Google won't stop the traffic; the clicks keep costing money until someone notices. This script notices: it fetches every final URL your keywords and ads use, classifies each page, labels the affected entities, and (optionally) pauses them until the page recovers — then re-enables them itself.
A monthly budget dies in one of two ways: it runs out on the 20th, or a third of it is still unspent on the 28th. Both are pacing failures, and both are visible weeks earlier — if someone projects the month-end spend every day. This MCC-level script is that someone: for every account with a declared monthly budget it computes month-to-date spend, projects the month-end total from the recent run-rate, and emails one digest flagging every account pacing outside tolerance.
A campaign that stops spending — or spends triple — rarely announces itself. Usually you find out days later, in a budget report or a client email. This MCC-level script checks every account's spend **today** against that account's own history and emails you the same day the pattern breaks, in either direction.
Google's Optimization Score influences everything from Partner status to how pushy the recommendations UI gets — and it moves without telling you. This MCC-level script makes it visible: every run appends each account's score (and its campaigns') to a history spreadsheet and emails a digest of anything below your floors.
Performance Max is a black box exactly where it hurts: which searches eat the budget without converting. The data exists — Google exposes PMax search terms through **search term insights** — but the UI buries it per campaign, per category, unrankable. This script digs it all out: every PMax search term with real clicks and no conversions, ranked worst-first, in a spreadsheet, with an email alert — ready to become negative keywords.
Performance Max spends part of its budget on Display and YouTube placements — and the UI barely shows you where. Mobile game apps, made-for-advertising sites, kids' content channels: your ads may be running there right now, and nothing in the campaign screen will tell you. This script pulls every placement your PMax campaigns served on, flags the suspicious ones, and emails you the paste-ready exclusion list every week.
Quality Score moves silently: Google won't tell you a keyword slid from 7 to 4 last Tuesday, but you pay for it on every auction from then on. This script snapshots every keyword's Quality Score **and its three components** daily, alerts you on drops, and labels chronic low-QS keywords. Because the components say *why* — expected CTR, ad relevance, landing page experience — the fix is usually obvious from the sheet alone.
Google grades every RSA headline and description — BEST, GOOD, LOW — and buries the grades three clicks deep, per ad. Nobody reviews them ad by ad, so LOW assets keep serving for months. This script sweeps the whole account and ranks the repeat offenders: the same LOW text used across many ads, where one rewrite improves dozens of ads at once.
Keeping ad copy consistent across dozens of ad groups is copy-paste drudgery, and it shows: half the account runs last quarter's messaging. This script builds responsive search ads from declared **ad frames** — reusable pools of headlines and descriptions with pinning rules. Label an ad group with a frame's name and the next run gives it a uniform RSA; update the frame, and every labeled ad group gets the new copy on the next run.
Google Ads matches your exact and phrase keywords to "close variants" — plurals, typos, reorderings, near-synonyms. Some of those variants quietly become your best performers, but as long as they are only search terms you can't bid on them, set their URL, or negative them apart. This script finds the close variants that have earned their place and promotes them to real keywords, automatically and with full audit labels.
Your search term report shows queries one by one — thousands of rows, each too small to judge. The patterns live one level up: the word "cheap" appearing in 400 different queries with terrible conversion rates, or "buy" quietly carrying half your revenue. This script breaks every search term into n-grams (single words, pairs, triples), sums the performance of every query containing each n-gram, and writes the ranked analysis to a spreadsheet — the fastest route to negative keyword ideas and bid insights you can't see query-by-query.
A themed shopping campaign — brand terms, a product line, a category — only stays themed if you keep fencing it. Product ads match whatever Google decides is relevant, so off-theme queries leak in daily and drag the campaign's ROAS with them. This script automates the fence: every search term that doesn't match your allowlist becomes a negative exact keyword. And because fences like this grow into the thousands, it handles capacity too — when the campaign's negative keyword limit fills up, the overflow goes into auto-created shared negative keyword lists attached to the same campaigns.
Shopping campaigns report at product level, but nobody reads thousands of product rows — so money-losing items hide in plain sight. This script aggregates every product that served in your Shopping/PMax retail campaigns, writes the full ranked list to a spreadsheet, and emails the two lists that matter: products spending without converting, and products converting below your ROAS floor.
Sitelinks outlive the pages they point to: seasonal landing pages get retired, category URLs change, and the sitelink keeps serving — straight into a 404 rendered under your otherwise healthy ad. Ad and keyword URLs get checked (that's the [Landing Page Link Checker](../landing-page-link-checker/)); sitelinks almost never do. This script closes the gap.
Price extensions lift CTR — Google shows them under your ad with real prices, making the ad bigger and more concrete. But maintaining them by hand across dozens of ad groups is the chore that quietly stops happening, and stale prices are worse than none. This script maintains them automatically: declare your price sets once, keyed by landing page, and every ad group advertising that page keeps an up-to-date price extension.
The Monday morning question is always the same: what happened last week, and what moved? One email answers it: last week's core metrics against the week before — cost, clicks, impressions, conversions, value, plus derived CPC, conv. rate, cost/conv and ROAS — and the campaigns that moved the numbers most, so the first coffee goes to the right campaign.
Every account has them: keywords that spend real money month after month and never convert. Each is small enough to hide in the averages; together they're a budget leak. This script finds every enabled keyword that spent at least `MIN_SPEND` in the window with zero conversions, ranks the list by cost, labels the offenders, and emails the digest.
The scripts are the starting point. We design custom automation and reporting on top of your own setup.
Start a project