Google Ads Scripts: Automation Templates & Guide

Managing Google Ads for 25 clients means checking 150+ campaigns daily—pausing underperforming keywords, adjusting bids based on performance, monitoring budgets, tracking quality scores, generating reports. That’s 20-30 hours per week on manual coordination.

Google Ads Scripts automate those repetitive tasks using JavaScript code that runs directly in your Google Ads account. Instead of manually checking campaigns every morning, scripts run on schedules you define—pause keywords below 1% CTR, send budget alerts when spend exceeds thresholds, export performance data to Google Sheets for reporting.

This guide explains what Google Ads Scripts are, how they work, 10 essential scripts for agencies, when scripts make sense vs. when you need broader workflow automation, and how to implement scripts that save 15-25 hours/week.

What Are Google Ads Scripts?

Google Ads Scripts are JavaScript programs that automate tasks within your Google Ads account. Scripts run on Google’s servers and can read campaign data, make changes (pause/enable ads, adjust bids, update labels), and send notifications—all without manual intervention.

What CAN be automated with scripts:

• Performance monitoring: Pause keywords below CTR/Quality Score thresholds, enable high-performers
• Bid management: Adjust bids based on performance, weather, inventory levels, custom business logic
• Budget tracking: Send alerts when campaigns approach daily/monthly limits
• Quality Score monitoring: Track Quality Score changes, identify declining keywords
• Reporting: Export data to Google Sheets, send automated email reports
• Competitor tracking: Monitor competitor ad positions and messaging
• Account health: Check for disapproved ads, broken URLs, low-impression-share campaigns
• Label management: Auto-tag campaigns/ad groups based on performance criteria

What CANNOT be automated with scripts:

• Creative production: Scripts can’t generate ad images, videos, or design assets
• Cross-channel coordination: Scripts work within Google Ads only (not Facebook, LinkedIn, TikTok)
• Strategic decisions: What audiences to target, what campaigns to launch, budget allocation across clients
• Multi-account workflow: Scripts run per account—can’t bulk-deploy campaigns across 25 clients simultaneously

Google Ads Scripts excel at automating single-channel PPC optimization tasks. For multi-client creative production, cross-channel campaigns, or complete workflow automation, agencies need broader platforms.

How Google Ads Scripts Work

Scripts follow a 4-step process: write code, authorize access, schedule execution, monitor results.

Step 1: Write Script (or Use Template)

Scripts are written in JavaScript. You can:

• Write custom scripts: If you know JavaScript, build exactly what you need
• Use templates: Google provides pre-built scripts; agencies share templates in communities
• Modify existing scripts: Start with template, customize for your specific needs

Example script (pause keywords below 1% CTR):

function main() {
  var keywords = AdsApp.keywords()
    .withCondition('CampaignStatus = ENABLED')
    .withCondition('Ctr < 0.01') // Less than 1% CTR
    .withCondition('Impressions > 100') // Minimum 100 impressions
    .get();

  while (keywords.hasNext()) {
    var keyword = keywords.next();
    keyword.pause();
    Logger.log('Paused keyword: ' + keyword.getText());
  }
}

This script finds all active keywords with CTR < 1% and > 100 impressions, then pauses them.

Step 2: Authorize Script

Scripts need permission to access your Google Ads account. When you run a script for the first time, Google prompts you to authorize access.

Authorization model:

• Scripts can only access accounts you manage
• Scripts run with your permission level (if you’re an account admin, scripts have admin access)
• Scripts can’t access accounts outside your Google Ads manager (MCC) hierarchy

Step 3: Schedule Execution

Scripts can run:

• Manually: Click “Run” button whenever you want
• Scheduled: Daily at specific time (e.g., every morning at 9 AM)
• Hourly: Every hour during business hours

Execution limits:

• 30-minute runtime limit: Scripts must complete within 30 minutes or they timeout
• 250 accounts per execution: Scripts can process up to 250 accounts in one run (useful for MCC-level scripts)

Most scripts run in 1-5 minutes. Complex cross-account scripts may approach 30-minute limit.

Step 4: Monitor Results

After scripts run, review:

• Logs: What actions did the script take? (Which keywords paused, which bids adjusted)
• Email notifications: Scripts can send email reports summarizing changes
• Google Sheets exports: Scripts can write data to spreadsheets for analysis

Scripts create audit trail—you know exactly what was changed and when.

10 Essential Google Ads Scripts for Agencies

1. Budget Alert Script

What it does: Sends email alert when campaign spend approaches daily budget (prevents unexpected overruns)

Why agencies need it: Monitoring 150 campaigns daily for budget overruns takes 15-20 hours/week. Script monitors automatically.

When to run: Every 4 hours during business hours

Template source: Google Ads Scripts Library (Budget Monitoring)

Time saved: 15 hours/week

2. Pause Underperforming Keywords

What it does: Automatically pauses keywords below CTR/Quality Score thresholds after minimum spend

Why agencies need it: Prevents wasting budget on keywords that don’t convert. Manual daily checks across 150 campaigns = 10-15 hours/week.

When to run: Daily at 9 AM

Criteria example:

• CTR < 1% AND impressions > 100 → Pause
• Quality Score < 5 AND impressions > 50 → Pause
• Conversion rate < 1% AND spend > $100 → Pause

Time saved: 10 hours/week

3. Bid Adjustment Based on Performance

What it does: Raises bids 10-20% for high-ROAS keywords, lowers bids 10-20% for low-ROAS keywords

Why agencies need it: Captures more traffic from winners, reduces waste on underperformers. Manual bid management across 500-1,000 keywords = 8-12 hours/week.

When to run: Daily at 8 AM (before business hours)

Logic example:

• ROAS > 4.0 AND impressions > 100 → Increase bid by 15%
• ROAS < 2.0 AND spend > $50 → Decrease bid by 15%
• Quality Score increased → Increase bid by 10%

Time saved: 8 hours/week

4. Quality Score Monitoring

What it does: Tracks Quality Score changes daily, exports to Google Sheets, sends alert when scores drop

Why agencies need it: Quality Score directly affects CPC and ad position. Monitoring manually across 500-1,000 keywords = 5-8 hours/week.

When to run: Daily at 10 AM

Alert triggers:

• Quality Score drops by 2+ points → Send email alert
• 10+ keywords drop below QS 5 in one day → Send urgent alert

Time saved: 5 hours/week

5. Keyword Mining Script

What it does: Analyzes Search Terms Report, identifies high-performing search queries not yet added as keywords, suggests additions

Why agencies need it: Search Terms Reports contain hundreds of queries. Manual review across 25 clients = 6-10 hours/week.

When to run: Weekly on Mondays

Logic:

• Search query has 5+ clicks, CTR > 2%, conversion rate > 3% → Suggest as new keyword
• Export suggestions to Google Sheets for review before adding

Time saved: 6 hours/week

6. Competitor Ad Position Tracking

What it does: Monitors competitor ad positions for target keywords, tracks messaging changes, sends alerts when competitors outrank you

Why agencies need it: Manual competitor checks across 100+ keywords = 4-6 hours/week.

When to run: Daily at 11 AM

Alerts:

• Competitor outranks you for 5+ target keywords → Send alert
• Competitor changes ad copy → Send alert with screenshot

Time saved: 4 hours/week

7. Ad Testing Script

What it does: Monitors A/B tests, identifies winning ads, pauses losers after statistical significance

Why agencies need it: Manual ad test monitoring across 50-100 active tests = 5-8 hours/week.

When to run: Weekly on Wednesdays

Logic:

• After 1,000 impressions per ad → Compare CTR
• Winner has 20%+ higher CTR with 95% confidence → Pause loser
• Export results to Google Sheets for review

Time saved: 5 hours/week

8. Cross-Account Performance Report

What it does: Exports performance data (spend, clicks, conversions, ROAS) for all accounts managed under MCC, sends weekly email report

Why agencies need it: Manual reporting across 25 client accounts = 12-20 hours/week.

When to run: Weekly on Fridays

Output: Google Sheets with one row per client, columns for key metrics, formatted for client presentation

Time saved: 12 hours/week

9. Account Health Check

What it does: Scans for common issues (disapproved ads, broken URLs, campaigns without conversions, low impression share, budget limits), sends weekly alert

Why agencies need it: Manual account audits across 25 clients = 8-12 hours/month.

When to run: Weekly on Mondays

Checks:

• Disapproved ads → List in alert
• Broken landing page URLs → List in alert
• Campaigns with 0 conversions in 30 days → Flag for review
• Impression share < 50% due to budget → Suggest budget increase

Time saved: 8 hours/month

10. Label Management Script

What it does: Auto-tags campaigns/ad groups/keywords based on performance (e.g., label “Top Performer” for ROAS > 5.0, “Needs Attention” for CTR < 1%)

Why agencies need it: Labels organize accounts and power automated reports. Manual tagging across 500-1,000 entities = 4-6 hours/month.

When to run: Weekly on Sundays

Label rules:

• ROAS > 5.0 → Label “Top Performer”
• ROAS < 2.0 → Label “Needs Optimization”
• CTR > 5% → Label “High Engagement”
• Quality Score < 5 → Label “Low Quality”

Time saved: 4 hours/month

Total time saved with 10 scripts: 60-80 hours/week = $9,000-12,000/week at $150/hour

Google Ads Scripts vs. Other Automation

Google Ads Scripts are one layer of automation. Understanding when to use scripts vs. other tools:

Google Ads Scripts vs. Automated Rules

When to use scripts: Cross-account reporting, custom logic (bid adjustments based on weather, inventory, etc.), exporting data to external systems

When to use Automated Rules: Simple tasks that don’t require coding (pause ads below CTR threshold, send alert when budget hits 80%)

Google Ads Scripts vs. API-Based Tools

When to use scripts: Budget-conscious agencies managing Google Ads only, custom automation logic vendors don’t support

When to use API tools: Multi-channel agencies (Google + Facebook + Microsoft), agencies without in-house developers

Google Ads Scripts vs. Full Workflow Automation Platforms

When to use scripts: PPC optimization for Google Ads (monitoring, bid adjustments, reporting)

When to use workflow platforms: Creative production, multi-channel deployment, cross-client reporting become bottlenecks (30+ hours/week)

Limitations of Google Ads Scripts & When to Use Alternatives

Scripts are powerful for Google Ads optimization, but have 5 key limitations:

1. Execution Limits (30-Minute Runtime, 250 Accounts)

Scripts must complete within 30 minutes. If processing 250 accounts with complex logic, you may hit this limit.

Workaround: Optimize scripts for speed (query fewer entities, use filters aggressively)

When to use alternative: If processing > 250 accounts or complex logic takes > 30 minutes → Use API-based tools (Optmyzr, Acquisio)

2. Technical Barrier (JavaScript Required)

Writing or customizing scripts requires JavaScript knowledge. Agencies without developers must:

• Use pre-built templates (limited customization)
• Hire developer to write scripts (one-time cost but ongoing maintenance)
• Use no-code alternatives (Automated Rules, API platforms)

When to use alternative: If no in-house JavaScript expertise and custom logic needed → Use API platforms with visual workflow builders (Optmyzr, Acquisio)

3. No Creative Automation

Scripts can pause/enable ads and adjust bids, but can’t:

• Generate ad creative (images, videos, headlines)
• Build landing pages
• Create ad copy variations

When to use alternative: If creative production is bottleneck (40+ hours/month designing 500 ad variations) → Use AI creative tools (Clyde, AdCreative.ai, Canva) or full workflow platforms

4. No Cross-Channel Coordination

Scripts work within Google Ads only. They can’t:

• Deploy campaigns to Facebook, LinkedIn, TikTok
• Coordinate messaging across channels (same creative on Google Display + Facebook)
• Consolidate cross-channel reporting

When to use alternative: If managing campaigns across Google + Facebook + LinkedIn → Use cross-channel platforms (Smartly, Celtra, Clyde)

5. Manual Maintenance Required

Scripts break when Google Ads API changes (1-2 times per year). You must:

• Monitor script logs for errors
• Update scripts when API changes
• Fix bugs when edge cases appear

When to use alternative: If no in-house developer for ongoing maintenance → Use API platforms where vendor maintains updates (Optmyzr, Acquisio, Clyde)

When scripts make sense:

• ✅ Managing Google Ads only (not multi-channel)
• ✅ Need custom logic vendors don’t support (bid adjustments based on weather, inventory, etc.)
• ✅ Budget-conscious (scripts are free)
• ✅ Have JavaScript expertise in-house (or willing to learn/hire)

When to use alternatives:

• ✅ Managing multi-channel campaigns (Google + Facebook + LinkedIn)
• ✅ Creative production is bottleneck (need AI ad generation)
• ✅ No JavaScript expertise (need visual workflow builders)
• ✅ Managing > 250 accounts (need enterprise API tools)

How to Get Started with Google Ads Scripts

5-step framework for agencies:

Step 1: Identify Highest-Time Manual Tasks (Week 1)

Track how your team spends time on Google Ads for one week:

• Daily campaign monitoring: ___ hours
• Bid adjustments: ___ hours
• Budget checks: ___ hours
• Reporting: ___ hours
• Quality Score tracking: ___ hours

Identify the top 2-3 highest-time activities. These are your scripting priorities.

Step 2: Find or Write Scripts (Week 1-2)

Option A: Use Pre-Built Templates (Fastest)

Google provides free script library:

• Google Ads Scripts Library — Official templates (budget monitoring, account health, reporting)
• Free Google Ads Scripts — Community templates
• PPCnerd Scripts — Agency-focused templates

Option B: Hire Developer to Write Custom Scripts

If pre-built templates don’t meet your needs:

• Hire freelance JavaScript developer (Upwork, Fiverr) — $500-2,000 for 3-5 custom scripts
• Contract agency-focused developer — Ongoing retainer for script maintenance

Option C: Learn JavaScript and Write Your Own

If you have time to learn:

• Codecademy JavaScript Course — 30 hours, beginner-friendly
• Google Ads Scripts Fundamentals — Official guide

Step 3: Test in Sandbox Account (Week 2-3)

Don’t deploy scripts to live client accounts immediately. Test first:

• Create test Google Ads account (or use non-critical client)
• Run script manually (don’t schedule yet)
• Review logs: Did script do what you expected?
• Check Google Ads account: Were changes correct?

Test for 1-2 weeks before deploying to all clients.

Step 4: Deploy Carefully to Client Accounts (Week 3-4)

After testing, deploy to 2-3 clients first:

• Choose clients with stable campaigns (not new launches)
• Run script daily for 1 week
• Monitor what script changed (logs, email notifications)
• Confirm changes improved performance (or at least didn’t hurt)

After 1 week of successful deployment, roll out to all 25 clients.

Step 5: Monitor and Iterate (Ongoing)

Scripts require ongoing maintenance:

• Weekly: Review script logs to confirm scripts ran successfully
• Monthly: Audit script changes (were they correct? Any false positives?)
• Quarterly: Optimize scripts (can logic be improved? Are thresholds too aggressive/conservative?)
• When API changes: Update scripts when Google releases API changes (1-2 times/year)

Allocate 2-4 hours/month for script monitoring and maintenance.

Total implementation time: 3-4 weeks Total time saved after implementation: 15-25 hours/week = $2,250-3,750/week at $150/hour

Best Practices for Google Ads Scripts

1. Start with Conservative Thresholds

When pausing keywords or adjusting bids, start conservative to avoid false positives:

• Pause keywords: CTR < 0.5% (not < 1.5%) to avoid pausing keywords too early
• Bid adjustments: ±10% (not ±25%) to avoid destabilizing campaigns
• Minimum spend: $50-100 before script takes action (ensures statistical significance)

Tighten thresholds after observing 30-60 days of script behavior.

2. Use Version Control for Scripts

Store scripts in version control (GitHub, GitLab):

• Maintain history of script changes (know what worked/broke)
• Collaborate with team (multiple people can edit scripts)
• Restore previous versions if new version breaks

Even simple version control (copy script to Google Doc with date before editing) prevents accidental deletions.

3. Add Error Handling and Notifications

Scripts should notify you when they fail:

try {
  // Script logic here
} catch (error) {
  MailApp.sendEmail('you@agency.com', 'Script Failed', error.message);
}

Without error handling, scripts fail silently and you won’t know until you manually check.

4. Test on Small Data Set First

Before running script on all campaigns, test on subset:

var campaigns = AdsApp.campaigns()
  .withCondition('CampaignName CONTAINS "Test"') // Only campaigns with "Test" in name
  .get();

After confirming script works on test campaigns, remove filter to run on all campaigns.

5. Document What Each Script Does

Add comments explaining script logic:

// This script pauses keywords with CTR < 1% and > 100 impressions
// Runs daily at 9 AM
// Sends email notification with list of paused keywords
// Last updated: 2026-01-15

When you revisit scripts 6 months later (or hand off to team member), comments explain what script does and why.

6. Combine Scripts with Other Automation Layers

Use scripts alongside Google’s native automation:

• Automated Bidding (Smart Bidding): Let Google optimize bids toward CPA/ROAS targets
• Automated Rules: Simple tasks (pause campaigns at budget limit)
• Scripts: Complex logic (cross-account reporting, custom bid adjustments, keyword mining)
• API platforms: Multi-channel coordination (Google + Facebook campaigns)

Layering automation creates redundancy—if one tool misses an issue, another catches it.

Frequently Asked Questions

Do I need to know JavaScript to use Google Ads Scripts?

Not necessarily. You can use pre-built templates from Google’s script library or community sources (Free Google Ads Scripts, PPCnerd). Templates cover 80% of common use cases (budget alerts, pause underperformers, quality score tracking, reporting).

For custom logic (bid adjustments based on inventory levels, weather, competitor activity), you’ll need JavaScript knowledge or hire a developer.

Are Google Ads Scripts free?

Yes. Scripts run on Google’s servers at no cost. There are no usage limits beyond runtime constraints (30-minute execution limit, 250 accounts per run).

Cost comes from:

• Time to write/customize scripts (if doing yourself)
• Developer fees (if hiring someone to write custom scripts)
• Ongoing maintenance (monitoring logs, updating when API changes)

Can scripts replace a Google Ads manager?

No. Scripts automate repetitive tasks (monitoring, bid adjustments, reporting), but humans remain critical for:

• Strategy: What campaigns to launch, what audiences to target, budget allocation
• Creative: Writing ad copy, designing landing pages, developing offers
• Client relationships: Explaining performance, recommending strategy changes, presenting results

Scripts remove 40-60% of manual coordination work, not strategic thinking.

How often do Google Ads Scripts break?

Scripts break when Google changes the Google Ads API (happens 1-2 times per year). When API changes, scripts using old API methods throw errors.

How to minimize breakage:

• Use Google’s official templates (Google maintains them when API changes)
• Join Google Ads Scripts community (stay informed about API changes)
• Monitor script logs weekly (catch errors early)
• Allocate 2-4 hours/quarter for script updates

What’s the difference between Google Ads Scripts and Google Apps Script?

Google Ads Scripts: Run inside Google Ads platform, designed specifically for Google Ads automation (bid management, reporting, account management)

Google Apps Script: General-purpose scripting for Google Workspace (automate Gmail, Sheets, Docs, Calendar)

Google Ads Scripts are built on Apps Script framework, but include additional Google Ads-specific libraries (AdsApp object for accessing campaigns, keywords, ads).

Can I run the same script across multiple client accounts?

Yes, using MCC-level scripts. Manager (MCC) accounts can run scripts that iterate through all managed accounts (up to 250 accounts per execution).

Example: Cross-account reporting script exports data for all 25 client accounts to one Google Sheet.

Ready to automate Google Ads with scripts? Start with 2-3 pre-built templates (budget alerts, pause underperformers, weekly reporting), test in sandbox account, deploy to 2-3 clients, then scale to all accounts. Scripts save 15-25 hours/week on manual monitoring and optimization, freeing your team for strategy and client relationships.