5 Google Ads Scripts Every Service Business Needs (And How to Set Them Up)

TL;DR: The average Google Ads account wastes $1,127.54/month — and most of that waste happens silently while you're not looking. Scripts are the only reliable way to monitor what Google won't tell you. This guide covers 5 essential scripts every service business needs, the automation hierarchy you should follow, and how to build custom scripts with AI assistance.

Google Ads gives you a dashboard. Scripts give you a safety net.

The difference matters because Google's interface is designed to show you what Google wants you to see — your spend, your clicks, your impressions. What it doesn't show you in real time: your budget burning 15% faster than planned, your best ad getting disapproved at 2 AM, or your landing page returning 404 errors while you're paying $8.58 per click.

That's why 63% of active advertisers use between 1-5 scripts, and PPC specialists run an average of 3.8 scripts per account. Scripts aren't optional overhead. They're the minimum viable protection for any account spending real money.

---

The Automation Hierarchy: Know Your Options Before You Script

Before diving into specific scripts, understand the four tiers of Google Ads automation — because scripts aren't always the answer.

Level 1: Automated Rules (Easiest — Covers 80% of Standard Tasks)

Built into Google Ads. No code required. Covers basic scenarios:

• Pause campaigns when daily spend exceeds threshold
• Enable/disable ads on a schedule
• Adjust bids when CPA exceeds target
• Send email alerts on performance changes

Best for: Simple conditional logic. "If X happens, do Y."

Limitation: Cannot process data across campaigns, cannot write to external sheets, cannot perform complex calculations.

Level 2: Google Ads Scripts (Intermediate — The Focus of This Guide)

JavaScript-based automation running inside Google Ads. Can read data, modify account elements, send emails, and write to Google Sheets.

Best for: Multi-campaign monitoring, anomaly detection, reporting automation, URL checking, search query analysis.

Limitation: 30-minute execution window per run, max 10,000 get or 10,000 mutate operations per run, cannot create campaigns from scratch.

Level 3: Google Ads API (Advanced)

Full programmatic control. Requires developer token, authentication credentials, and a manager account.

Best for: Large-scale account management, custom dashboards, inventory-based ad management, enterprise-level automation.

Limitation: Requires coding infrastructure, developer maintenance, and API quota management.

Level 4: AI-Augmented Automation (Emerging)

Combines Google Apps Script with AI APIs (ChatGPT, Claude) for natural-language analysis of account data.

Best for: Search term categorization, ad copy analysis, automated audit reports, anomaly interpretation.

Limitation: API costs ($0.005-$0.015 per 1,000 tokens), requires testing before production use.

Which Level Do You Need?

Frederick Vallaeys, CEO of Optmyzr, recommends scripts specifically for accounts spending over $5,000/month — the point where silent waste becomes materially painful.

---

The 5 Essential Scripts Every Service Business Needs

These five scripts form a minimum viable monitoring stack. They cover the scenarios most likely to silently drain your budget.

---

Script 1: Budget Pacing Alert

What it does: Compares your month-to-date actual spend versus expected spend and alerts you when variance exceeds a threshold.

Why you need it: Google can spend up to 2x your daily budget on any given day. Over a month, this is supposed to average out — but it often doesn't. Without pacing alerts, you won't know your monthly budget is 15% overdelivered until it's too late to course-correct.

For service businesses, this matters even more. A plumber paying $10-$30 per click who overspends by 15% in the first two weeks has no budget left for high-intent weekend searches.

The hidden problem: Timezone mismatches are "the single most common cause of incorrect spend calculations" in pacing scripts. If your script runs in UTC but your campaigns target US Eastern, your pacing numbers will be wrong every single day.

Setup Instructions:

1. Navigate to Google Ads > Tools & Settings > Bulk Actions > Scripts
2. Click the "+" button to create a new script
3. Name it: Budget Pacing Alert - [Account Name]
4. Paste the script code (source below)
5. Click "Authorize" to grant permissions
6. Click "Preview" first — review the Logs panel before going live
7. Schedule: Daily at 10 AM (after morning spend data settles)

Key Configuration Variables:

THRESHOLD_PERCENT = 15      // Alert when variance exceeds 15%
EMAIL = 'your@email.com'    // Alert recipient
TIMEZONE = 'America/New_York'  // MUST match your campaign timezone
MONTHLY_BUDGET = 5000       // Your actual monthly budget cap

Critical settings:

• Set the timezone to match your campaign targeting timezone, not your personal timezone
• Use PropertiesService to suppress duplicate alerts within 4-hour windows (prevents email flooding)
• Set the threshold at 15% for most accounts — tighter thresholds create alert fatigue

What to do when it fires:

1. Check if the overspend is concentrated in one campaign or spread across all
2. Review if a specific keyword or ad group is driving unexpected volume
3. Manually reduce daily budgets on non-essential campaigns to rebalance
4. If underspending, check for disapproved ads or broken URLs eating your impression share

Script source: Available at ppc.io/blog/google-ads-scripts and ads-scripts.com (Check Daily Budget / Check Monthly Budget scripts).

---

Script 2: Disapproved Ads Monitor

What it does: Scans all active ads across your account, identifies any that have been disapproved by Google, extracts the specific policy violation reason, and sends you a structured alert with campaign name, ad group, headline, and policy details.

Why you need it: Google can disapprove ads at any time — and does so without prominent notification. Your best-performing ad could get flagged at 2 AM on a Friday and stop running entirely. For service businesses in regulated verticals (legal, healthcare, financial), this happens more frequently than you'd expect.

The impact is immediate: if your top ad gets disapproved and you have only one other ad in the group, all traffic shifts to your second-best performer. If you have no backup, the entire ad group goes dark — and you keep paying for competitors' clicks on your brand terms.

A real scenario: A dentist running ads for "emergency dental care" had their primary ad disapproved for healthcare policy violations. The disapproval happened on a Thursday evening. They didn't notice until the following Monday — losing an entire weekend of high-intent emergency searches at $7.85 per click.

Setup Instructions:

1. Create a new script: Disapproved Ads Monitor - [Account Name]
2. Paste the disapproval monitoring script code
3. Authorize and preview
4. Schedule: Every 2 hours during business hours for regulated verticals (legal, healthcare, finance); Daily at 8 AM for other industries

Key Configuration:

EMAIL = 'your@email.com'
INCLUDE_PAUSED = false       // Only check active campaigns
CAMPAIGN_FILTER = ''         // Leave empty for all campaigns

Output structure: The script generates a report containing:

What to do when it fires:

1. Review the specific policy violation
2. Create a compliant replacement ad immediately
3. Appeal the disapproval if you believe it's incorrect (Google Ads > Ads > Appeal)
4. Maintain at least 2 active RSAs per ad group so one disapproval never kills your traffic

Script source: Available at ppc.io/blog/google-ads-scripts (Disapproved Ads Alert script).

---

Script 3: Broken URL Checker

What it does: Checks all final URLs across your active ads for HTTP 4xx (not found) and 5xx (server error) responses, then flags any broken links to a Google Sheet or email.

Why you need it: Broken landing pages are one of the most expensive silent failures in Google Ads. Every click to a 404 page is pure waste — the visitor bounces immediately, you pay the full CPC, and your Quality Score degrades over time.

This is especially dangerous for service businesses that frequently update their websites. A redesign that changes URL structures, a hosting issue that takes down a specific page, or a CMS update that breaks a form — any of these can turn a profitable campaign into a money pit overnight.

The math is brutal: If you're a law firm paying $8.58 average CPC and your landing page goes down for 48 hours during business days, with an average of 20 clicks per day, that's $343.20 wasted — plus the Quality Score damage that raises your CPC for weeks afterward.

Setup Instructions:

1. Create a new script: Broken URL Checker - [Account Name]
2. Create a Google Sheet for the output (name it "Broken URL Report - [Account]")
3. Copy the sheet URL into the script configuration
4. Authorize and preview
5. Schedule: Daily at 6 AM (before business hours)

Key Configuration:

SPREADSHEET_URL = 'https://docs.google.com/spreadsheets/d/...'
MAX_CHECKS = 500            // Prevents exceeding 30-min execution limit
SLEEP_MS = 1000             // 1-second delay between requests (avoid bot detection)
CHECK_DISPLAY_URLS = false  // Focus on final URLs only

Critical implementation notes:

• The MAX_CHECKS parameter is essential. Large accounts with thousands of ads will time out without this limit. Start at 500 and increase only if your script completes well within the 30-minute window.
• The SLEEP_MS delay (1 second between requests) prevents your own server from flagging the script as a bot and blocking it. Don't reduce this below 500ms.
• The script checks for both explicit HTTP error codes (404, 500, 503) and slow-loading pages that may indicate server issues.

What to do when it fires:

1. Check if the broken URL is a temporary server issue or a permanent change
2. If temporary: contact your hosting provider
3. If permanent: update the ad's final URL immediately
4. If multiple URLs are broken: pause affected ads until landing pages are restored
5. Check your ad extensions too — sitelinks and callout URLs can also break

Script source: Available at ppc.io/blog/google-ads-scripts (Broken Link Checker) and ads-scripts.com (Link Checker de Luxe — also detects "not available" text on pages).

---

Script 4: Search Query Mining / N-Gram Analysis

What it does: Pulls search term data from the last 14 days, breaks queries into 1-4 word phrases (n-grams), and analyzes which word combinations drive conversions versus which waste budget. Outputs results to a Google Sheet for review.

Why you need it: This is the most strategically valuable script in the stack. While the other four scripts prevent waste, this one actively finds opportunities.

The core insight: instead of analyzing "emergency plumber near me open now" as a single search term, n-gram analysis examines "emergency," "plumber," "near me," and "open now" as separate data points. This reveals patterns invisible at the query level.

For example, you might discover that:

• Every query containing "emergency" converts at 14%
• Every query containing "DIY" has zero conversions
• Queries with "cost" or "price" convert at 2x your average
• Queries with "free" never convert

This analysis directly feeds your negative keyword strategy and helps you identify new high-intent keywords, which we covered in our keyword strategy guide.

Real-world impact: Accounts with negative keywords convert at 13% versus 4.6% without — a 3x improvement. N-gram analysis is the systematic way to build and maintain that negative keyword list.

Setup Instructions:

1. Create a new script: N-Gram Analysis - [Account Name]
2. Visit Nils Rooijmans' website and copy the updated Brainlabs N-Gram script
3. Create a dedicated Google Sheet ("N-Gram Analysis - [Account]")
4. Configure the variables (see below)
5. Authorize and preview
6. Schedule: Weekly on Mondays at 6 AM for most accounts; Daily for high-volume accounts (1,000+ clicks/week)

Key Configuration Variables:

// Date range (static — must manually update or use dynamic dates)
var startDate = '2026-03-01';
var endDate = '2026-03-26';

// Campaign filtering
var campaignNameContains = '';           // Filter to specific campaigns
var campaignNameDoesNotContain = '';     // Exclude campaigns
var ignorePausedCampaigns = true;
var ignorePausedAdGroups = true;

// N-gram depth (CRITICAL: change from default 2 to 4)
var minNGramLength = 1;
var maxNGramLength = 4;

// Thresholds
var queryCountThreshold = 0;
var impressionThreshold = 10;
var clickThreshold = 0;
var costThreshold = 0;
var conversionThreshold = 0;

// Output
var spreadsheetUrl = 'https://docs.google.com/spreadsheets/d/...';
var currencySymbol = '$';
var clearSpreadsheet = true;

// Negative keyword filtering
var checkNegatives = true;  // Excludes queries already caught by negatives

Output Structure (for 4-word n-gram depth):

The script generates 12 tabs in your Google Sheet:

Metrics tracked per n-gram: Clicks, Impressions, Cost, Conversions, Conversion Value, CTR, CPC, Conversion Rate, Cost per Conversion, ROAS (Conversion Value/Cost).

How to use the output:

Step 1: Find negative keyword candidates (1-2 word n-grams)

Filter the account-level 1-word tab by:

• High cost + zero conversions — immediate negative keyword candidates
• High impressions + low CTR — your ads show but people don't click (irrelevant match)
• High clicks + zero conversions — budget drain

Common waste words for service businesses:

Step 2: Find new keyword opportunities (3-4 word n-grams)

Filter the 3-4 word tabs by:

• Conversions > 0 + good CPA — promote these to exact or phrase match
• High conversion rate — even with low volume, these patterns indicate intent

Step 3: Validate against existing keywords

Enable checkNegatives = true to exclude queries already handled by your existing negative keyword lists. This prevents double-work and focuses your analysis on gaps.

Important note: The date range in this script is static. You must manually update startDate and endDate each time you want fresh data, or modify the script to use dynamic date ranges.

Script source: nilsrooijmans.com (updated Brainlabs N-Gram script with GAQL support, updated March 2025).

---

Script 5: Performance Anomaly Detector

What it does: Compares the last 7 days of account performance against a 28-day baseline, flags any metric that deviates beyond defined thresholds, and sends an email alert with specifics.

Why you need it: Google Ads performance doesn't degrade gradually — it shifts suddenly. A competitor enters the auction and your CPC jumps 30% overnight. A Smart Bidding strategy exits learning phase and starts bidding aggressively. A seasonal trend fades and your CTR drops without warning.

Without anomaly detection, you're checking your account manually and hoping to catch these shifts before they drain your budget. For service businesses where a single lead can be worth $500-$5,000, even one day of undetected anomalies is costly.

What it catches that manual monitoring misses:

• Smart Bidding instability — Target CPA or ROAS strategies can oscillate wildly during and after learning phase
• Quality Score degradation — A landing page change that tanks your QS, raising CPCs across the account
• Seasonal shifts — Demand patterns changing faster than your bid strategy can adjust
• Competitor activity — New entrants or aggressive bidding from existing competitors
• Conversion tracking breaks — A tracking tag that stops firing, making Google think conversions dropped to zero (and bidding accordingly)

Setup Instructions:

1. Create a new script: Anomaly Detector - [Account Name]
2. Paste the anomaly detection script code
3. Configure thresholds (see below)
4. Authorize and preview
5. Schedule: Daily at 9 AM

Key Configuration:

var EMAIL = 'your@email.com';
var CTR_THRESHOLD = 20;        // Alert on 20% CTR deviation
var CPA_THRESHOLD = 25;        // Alert on 25% CPA deviation
var CONVERSION_THRESHOLD = 30; // Alert on 30% conversion count drop
var COST_THRESHOLD = 20;       // Alert on 20% cost deviation
var LOOKBACK_DAYS = 7;         // Compare last 7 days
var BASELINE_DAYS = 28;        // Against 28-day average

Threshold recommendations by business type:

Emergency services get tighter thresholds because their keywords are expensive ($10-$30/click) and margins are thin — a 20% CPA increase is immediately material.

What to do when it fires:

1. CTR drop: Check ad copy (disapprovals?), check competitors (new entrants?), check search terms (irrelevant matches?)
2. CPA spike: Check if conversion tracking is working, check landing page load speed, check bid strategy status
3. Conversion drop: First rule out tracking issues before making campaign changes. A broken tracking tag looks identical to a real conversion drop.
4. Cost spike: Check for new broad match query matches, check if Google expanded to Search Partners, check device breakdown

Script source: Available at ppc.io/blog/google-ads-scripts (Account Anomaly Detector) and ads-scripts.com (Account/Campaign Metrics Out of Limits Alerts).

---

Bonus Scripts Worth Adding After the Core 5

Once your core monitoring stack is running, these additional scripts address specific pain points:

ROAS Deviation Alert

What it does: Alerts when actual ROAS deviates from your target ROAS — particularly useful if you're running Target ROAS bidding and want to catch strategy drift.

Why it matters: Smart Bidding strategies can quietly underperform their targets during learning phases or after account changes. This script catches the gap before it compounds.

Source: ads-scripts.com — "Check ROAS Deviation" script.

Expensive CPC Detector

What it does: Identifies clicks with abnormally high CPCs — the individual clicks that cost 3-5x your average. These often indicate competitive bidding wars on specific queries or Smart Bidding overbidding.

Why it matters for service businesses: Legal services average $8.58 per click. An expensive CPC anomaly could mean individual clicks at $25-$40 — and if those clicks don't convert, each one is a significant loss.

Source: ads-scripts.com — "Expensive CPC Detector" script.

PMax Performance Monitor

What it does: Extracts Performance Max asset group data into Google Sheets, showing metrics Google buries in the UI. Tracks brand vs non-brand traffic split, logs non-converting search terms, and suggests placement exclusions.

Why it matters: As we cover in our Performance Max guide, PMax operates as a black box. These scripts provide the visibility Google deliberately withholds:

• PMax Insights Script (Mike Rhodes) — Most comprehensive PMax visibility tool
• PMax Non-Converting Search Terms Alert — Logs zero-conversion terms with email alerts
• PMax Brand Traffic Analyzer — Shows how much PMax cannibalizes your brand traffic
• PMax Placement Exclusion Suggestions — Surfaces low-quality placements for exclusion

Unauthorized Changes Alert

What it does: Detects when modifications are made by unauthorized Google accounts — catching both Google rep changes and accidental edits.

Why it matters: Google reps routinely make unauthorized changes to accounts. One agency documented reps "going behind our back and dealing directly with our mutual client." This script catches those changes in real time.

Source: ads-scripts.com — "Unauthorized Changes Alert" script.

Search Partners Alert

What it does: Monitors whether Search Partners has been enabled on your campaigns — a setting Google sometimes turns on through auto-apply recommendations.

Why it matters: Search Partners traffic typically has 52% higher CPC and 44% lower CTR than standard Search. If it gets silently enabled, you'll see your metrics degrade without understanding why.

---

Script Usage Statistics: Where You Fit

Understanding how the industry uses scripts helps you benchmark your own setup:

The maintenance burden is real — 68% of script users spend more than 5 hours per month on upkeep. This includes updating scripts when Google changes its API, reviewing outputs, acting on alerts, and debugging failed runs.

Quarterly maintenance checklist:

• Check scripts against Google Ads release notes for API changes
• Run preview mode tests on all scripts to confirm outputs
• Review run history for silent failures in the past 30 days
• Update date ranges in static-date scripts (like N-gram)
• Verify email recipients are still correct
• Check Google Sheet storage (old data accumulating)

---

Setting Up Your First Script: Step-by-Step Walkthrough

If you've never created a Google Ads script before, here's the exact process:

Step 1: Access the Scripts Editor

1. Log into Google Ads
2. Click Tools & Settings (wrench icon) in the top navigation
3. Under Bulk Actions, click Scripts
4. You'll see a list of existing scripts (empty if this is your first)

Step 2: Create a New Script

1. Click the blue "+" button
2. You'll see a code editor with a default function main() {} template
3. Name your script descriptively: [Type] - [Account] - [Date Created]
   • Example: Budget Pacing Alert - Smith Plumbing - 2026-03

Step 3: Paste and Configure

1. Copy the script code from the source URL
2. Paste it into the editor, replacing the default template
3. Update configuration variables at the top of the script:
   • Email addresses
   • Timezone
   • Thresholds
   • Google Sheet URLs (if the script outputs to Sheets)

Step 4: Authorize

1. Click "Authorize" — this grants the script permission to read/modify your account
2. Sign in with your Google account when prompted
3. Review and accept the permissions

Step 5: Preview (Critical Safety Step)

1. Click "Preview" — this runs the script in read-only mode
2. Review the Logs panel — check for errors and unexpected outputs
3. Review the Changes panel — see what modifications the script would make
4. If using Google Sheets output, verify the sheet populated correctly

Never skip preview. A misconfigured script can pause campaigns, change bids, or modify budgets across your entire account.

Step 6: Schedule

1. Click "Save" after preview confirms correct behavior
2. Set the frequency:
   • Monitoring scripts (Budget Pacing, Disapproved Ads, Broken URLs, Anomaly Detector): Daily
   • Analysis scripts (N-Gram Analysis): Weekly
3. Set the time to run (early morning recommended — before business hours)

Step 7: Staged Rollout

Before running any script on your full account:

1. Apply to a labeled subset first — label 5-10% of campaigns with a test label
2. Configure the script to only process labeled campaigns
3. Run for one week and review outputs
4. Expand to full account only after confirming correct behavior

For scripts that make changes (bid adjustments, pausing ads), also:

• Write previous values to a Google Sheet before making modifications (rollback strategy)
• Set conservative thresholds initially and tighten over time

---

Building Custom Scripts with AI ("Vibe Coding")

12% of PPC professionals use custom scripts — and the barrier to entry has dropped dramatically with AI assistance.

If the pre-built scripts above don't cover your specific need, you can build custom scripts using ChatGPT or Claude without deep JavaScript knowledge:

The Process

Step 1: Describe the problem clearly

Write a plain-English description of what you want the script to do. Be specific about:

• What data you need to read
• What conditions should trigger an action
• What the action should be (email, Sheet, account change)
• What thresholds or filters to apply

Example prompt:

"Write a Google Ads script that checks all active Search campaigns every day at 8 AM. For each campaign, compare the average CPC in the last 7 days versus the previous 28 days. If any campaign's CPC has increased by more than 25%, send me an email with the campaign name, old CPC, new CPC, and percentage change. Output the data to a Google Sheet at [URL]."

Step 2: Paste into ChatGPT or Claude

Use the system prompt: "You are a Google Ads automation expert. Generate a Google Ads script using the current Google Ads Scripts API (GAQL, not AWQL)."

Step 3: Copy generated code into the script editor

Paste the AI-generated code into Google Ads > Scripts > New Script.

Step 4: Preview and debug

Run in preview mode. If you get errors:

1. Copy the error message
2. Paste it back to the AI with: "I got this error when running the script in Google Ads. Fix it."
3. Iterate 2-3 rounds until functional

Step 5: Test with labeled campaigns

Apply to a small subset before full deployment.

Tips for Better AI-Generated Scripts

• Use low temperature (0-0.3) for consistency in code generation
• Specify GAQL, not AWQL — Google deprecated AWQL in 2025, and AI models sometimes generate outdated syntax
• Include timezone requirements — AI-generated scripts often default to UTC
• Request error handling — Ask the AI to include try/catch blocks and logging
• Batch operations — If querying large datasets, ask the AI to include pagination and rate limiting

AI-Augmented Script Ideas for Service Businesses

Integration approach: Export data via Google Ads Scripts to Google Sheets, then use a separate Google Apps Script to call the AI API for analysis. This keeps the Google Ads script simple and within its execution limits.

API costs are minimal: At $0.005 per 1,000 input tokens and $0.015 per 1,000 output tokens, analyzing a month of search term data for a typical service business account costs under $1.

---

The Complete Script Stack: Recommended Schedule

Here's the full monitoring setup for a service business spending $5,000-$15,000/month:

Time investment: Expect 2-3 hours for initial setup of all 5 core scripts, plus 1-2 hours per week reviewing outputs and acting on alerts. The 68% of script users spending 5+ hours/month on maintenance includes quarterly updates and custom script development.

---

Scripts Alone Won't Save You

Scripts are necessary but not sufficient. They catch problems and surface data — but they don't solve the structural issues covered elsewhere in this series.

Scripts protect your budget. Strategy determines whether that budget generates returns.

For the strategic foundation these scripts monitor:

• Start with our campaign setup guide to ensure your account structure is correct from day one
• Build your negative keyword strategy using N-gram script data
• If you're considering Performance Max, read our PMax guide before deploying — and use the PMax monitoring scripts to track what Google won't show you

---

Key Takeaways

The 5 Non-Negotiable Scripts

1. Budget Pacing Alert — Prevents overspend before it happens
2. Disapproved Ads Monitor — Catches silently killed ads
3. Broken URL Checker — Stops paying for clicks to dead pages
4. N-Gram Analysis — Finds waste patterns and new keyword opportunities
5. Performance Anomaly Detector — Catches sudden metric shifts

The Numbers That Matter

Action Plan

Week 1: Set up Budget Pacing Alert and Broken URL Checker (highest immediate ROI).

Week 2: Add Disapproved Ads Monitor and Performance Anomaly Detector.

Week 3: Deploy N-Gram Analysis script. Run first analysis and build initial negative keyword list.

Week 4: Review all script outputs. Adjust thresholds based on first month of data. Consider bonus scripts.

Ongoing: Weekly review of N-gram data. Monthly threshold calibration. Quarterly script maintenance check.

The average account wastes over $13,500 per year. Five scripts and a few hours of setup won't eliminate all of that — but they'll catch the silent failures that account for the majority of preventable waste.

---

This article is part of the Google Ads Efficiency Playbook 2026 series. Data sourced from PPC Land (15,000 accounts), WordStream (16,000 campaigns), GrowthSpree (43 enterprise accounts), and independent PPC practitioners.