How to Install a Google Ads Script in Performance Max Campaigns for Better Automation and Control

Understanding Google Ads Scripts

Before installing, it’s essential to understand what Google Ads scripts are and how they function within the broader Google Ads ecosystem. This understanding helps tie technical automation back into a broader Digital Marketing Strategy Development and channel mix.

What Are Google Ads Scripts?

Google Ads scripts are JavaScript-based snippets that run within your Google Ads account to automate tasks, retrieve data, and make changes without manual intervention. They’re commonly used to:

• Generate reports and send alerts
• Pause or enable campaigns based on performance.
• Adjust budgets dynamically
• Apply or modify labels for easier filtering.
• Push performance data to Google Sheets or email

Think of them as customizable automation tools, especially useful when managing large accounts or when native platform controls don’t offer what you need.

How Scripts Typically Work

A script can:

• Read data from your campaigns (impressions, cost, conversions)
• Make logic-based decisions (e.g., “If CPA > $100, pause campaign”)
• Write data to external platforms (e.g., Sheets, Slack, email)
• Schedule itself to run hourly, daily, or weekly.

Scripts live under:

Google Ads → Tools & Settings → Bulk Actions → Scripts

They can be account-specific or managed via MCC (My Client Center) for advertisers managing multiple clients. If your agency or in-house team already runs structured Google Analytics Services, scripts are a natural addition to your measurement stack and reporting system.

Why Advertisers Want Scripts for PMax

Performance Max is a highly automated campaign type, but also a black box. You can’t control individual keywords or placements, and access to data is limited.

Advertisers turn to scripts to:

• Improve reporting transparency
• Track budget pacing and overspend
• Flag performance anomalies
• Group and label campaigns for organized views
• Apply consistent rules across multiple PMax campaigns.

Can You Apply Scripts to PMax Campaigns?

The capabilities of Google Ads scripts, particularly in conjunction with Performance Max, have undergone significant evolution. Here’s what’s currently possible, especially when you’re managing complex accounts through structured Google Ads Management Services or full-funnel Digital Marketing Services.

The Current Answer: Yes, with Expanding Capabilities

Scripts can now interact with Performance Max campaigns at multiple levels, thanks to recent API updates and the introduction of the mutate function.

You can now:

• Read campaign-level data (cost, conversions, impressions, etc.)
• Write campaign-level labels and manage campaigns
• Pause or enable Performance Max campaigns
• Monitor budget pacing and daily spend
• Create Performance Max campaigns (using the mutate function)
• Access and manage asset groups (limited operations)
• Pull performance data into Google Sheets
• Run scripts across MCC accounts to manage Performance Max at scale

You still can’t:

• Directly modify individual creative assets (headlines, descriptions, images)
• Access detailed placement data (where ads appear)
• Override Smart Bidding strategies
• Use traditional AdsApp methods for campaign creation (must use mutate)

For accounts where PMax supports high-value funnels driven by Ecommerce PPC or lead-gen offers, these limitations mean scripts focus mainly on structure, pacing, and reporting—not creative rotation.

What Kind of Scripts Work with Performance Max?

// Modern approach for Performance Max operations
function createPerformanceMaxCampaign() {
  const operation = {
    // Campaign creation logic using mutate
  };
  const result = AdsApp.mutate(operation);
  return result;
}

if (campaign.getAdvertisingChannelType() === "PERFORMANCE_MAX") {
   // Safe to proceed with Performance Max-specific logic
}

// Basic asset group access
const assetGroups = campaign.assetGroups().get();
while (assetGroups.hasNext()) {
  const assetGroup = assetGroups.next();
  Logger.log("Asset Group: " + assetGroup.getName());
}

Prerequisites Before You Install a Script

Before installing the script, it’s crucial to have the necessary account set up, permissions, and tools in place. Google Ads scripts are powerful, but even a small mistake in setup can prevent your script from running, or worse, cause unwanted changes.

Here’s what to check first:

1. Access Level: You Must Have Admin or Standard Permissions

Only users with Admin or Standard access in the Google Ads account can install and authorize scripts.

If you encounter the “Insufficient permissions” error during setup, please double-check your user role. If you’re working with an external team providing Enterprise Digital Marketing or Franchise Digital Marketing, make sure access is aligned with responsibilities.

2. Work in the Right Account (MCC vs Individual)

If you manage multiple accounts through a Google Ads Manager (MCC) account, you can run MCC-level scripts that work across all client accounts.

If you’re managing a single account, you’ll install the script directly in that account’s “Bulk Actions” tab.

MCC scripts are great for agencies managing multiple PMax campaigns at scale.

3. Enable Google Ads Scripts in Your Tools Menu

Navigate to:

Tools & Settings → Bulk Actions → Scripts

If you’ve never used scripts before, this section may be empty. That’s normal, this is where you’ll paste and manage scripts manually.

4. Connect Google Sheets (For Reporting Scripts)

Many popular PMax scripts push data into Google Sheets. To enable this:

• Make sure your Google account is signed in
• Allow OAuth authorization when prompted.
• Create and share the Google Sheet using the same account as the one used in Ads.

Tip: Pre-create a spreadsheet and grab the URL, it’ll be needed in most script templates.

5. Grant OAuth Access When Running a Script for the First Time

After pasting your script and clicking “Authorize,” Google will ask you to:

• Approve access to manage campaigns
• Allow access to third-party integrations (e.g., Sheets, Gmail for alerts)

Important: If you skip this, the script won’t run. You must complete authorization before previewing or scheduling.

6. Understand Script Timing and Limits

• Standard scripts can run every hour or every 30 minutes, depending on the setup.
• Each script run has a 30-minute execution limit.
• You can schedule scripts by time of day or run them manually.

For high-frequency tasks (like spend alerts), use hourly runs. For daily reporting, once per day is enough.

Step-by-Step: How to Install Google Ads Script to PMax

Once your prerequisites are in place, installing a script into your Google Ads account is a straightforward process. Follow this step-by-step guide to set up your first working script for Performance Max (PMax) campaigns.

Step 1: Open the Scripts Manager in Google Ads

Go to:

Tools & Settings → Bulk Actions → Scripts

You’ll land in your script dashboard. If it’s your first time here, you’ll see an empty page.

Step 2: Click the Blue “+” Button to Create a New Script

This opens the script editor where you’ll paste your JavaScript code. Scripts can be copied from Google’s library, GitHub, or written manually.

Step 3: Paste or Write Your Script

Here’s a simple example that logs the names and impressions of all PMax campaigns in your account:

function main() {
  var campaigns = AdsApp.campaigns()
      .withCondition("AdvertisingChannelType = 'PERFORMANCE_MAX'")
      .get();

  while (campaigns.hasNext()) {
    var campaign = campaigns.next();
    Logger.log("Campaign: " + campaign.getName() + 
               " | Impressions: " + campaign.getStatsFor("LAST_7_DAYS").getImpressions());
  }
}

If you’re already using internal dashboards to support Enterprise PPC Marketing, this kind of script-based logging helps ensure your PMax visibility isn’t a blind spot.

Step 4: Authorize the Script

Click “Authorize” and follow the prompts. This step gives the script permission to access your campaigns, Sheets, or any other connected tools.

If your script includes Sheets integration, you’ll also need to authorize access to your Google Drive.

Step 5: Preview the Script

Before running, always click “Preview” to:

• See what data the script will read or modify
• Check for errors in syntax, access, or conditions.
• View logs in the bottom console (Logger.log)

You’ll get a full breakdown of which campaigns the script accessed and what actions it would’ve taken, without actually changing anything.

Step 6: Run the Script or Set a Schedule

Once the preview is clean:

• Click “Run” to execute immediately
• Or click “Create Schedule” to run the script daily, hourly, or weekly.

For performance monitoring or reporting, daily runs are typical. For alert scripts (budget overages), set the interval to hourly.

Example Output in Logger (for the sample above):

Campaign: PMax - California | Impressions: 8,543  
Campaign: PMax - Product Feed | Impressions: 14,920

If you’re exporting to Sheets, the next step would be appending each row via:

sheet.getRange(row, 1).setValue(campaign.getName());

Sample Google Ads Scripts for PMax (Code Included)

While PMax offers limited customization, several powerful scripts still work well, especially for monitoring, reporting, and organizing your campaigns. Below are three tested script examples designed to help you automate key tasks and gain better visibility.

Script 1: Export PMax Campaign Performance to Google Sheets

Use Case: Automatically push campaign-level performance data (cost, conversions, CPA) from PMax campaigns into a connected Google Sheet.

function main() {
  var sheetUrl = "PASTE_YOUR_SHEET_URL_HERE";
  var sheet = SpreadsheetApp.openByUrl(sheetUrl).getSheetByName("PMax Report");
  sheet.clearContents();
  sheet.appendRow(["Campaign Name", "Cost", "Conversions", "CPA"]);

  var campaigns = AdsApp.campaigns()
    .withCondition("AdvertisingChannelType = 'PERFORMANCE_MAX'")
    .get();

  while (campaigns.hasNext()) {
    var c = campaigns.next();
    var stats = c.getStatsFor("LAST_7_DAYS");
    var name = c.getName();
    var cost = stats.getCost();
    var conv = stats.getConversions();
    var cpa = conv > 0 ? (cost / conv) : 0;
    sheet.appendRow([name, cost, conv, cpa]);
  }
}

What You’ll Need:

• A Google Sheet with a tab named “PMax Report”
• OAuth authorization to Sheets during script setup

You can later pair this data with CRO or funnel analytics from your User Behavior Analytics setup to see where traffic turns into revenue.

Script 2: Budget Overspend Warning for PMax

Use Case: Alerts you via log or email when a PMax campaign exceeds its daily or weekly budget by a given threshold.

function main() {
  var threshold = 100; // dollars
  var campaigns = AdsApp.campaigns()
    .withCondition("AdvertisingChannelType = 'PERFORMANCE_MAX'")
    .get();

  while (campaigns.hasNext()) {
    var c = campaigns.next();
    var cost = c.getStatsFor("YESTERDAY").getCost();
    if (cost > threshold) {
      Logger.log("⚠️ " + c.getName() + " spent $" + cost + " yesterday!");
      // Optional: Email alert logic here
    }
  }
}

Pro Tip: Add your email logic with MailApp.sendEmail(...) if you’re using a Gmail-linked Ads account.

Script 3: Automatically Label All PMax Campaigns

Use Case: Apply a “PMax” label to all Performance Max campaigns, useful for filtering, bulk edits, and scripts that work off labels.

function main() {
  var labelName = "PMax";
  if (!AdsApp.labels().withCondition("Name = '" + labelName + "'").get().hasNext()) {
    AdsApp.createLabel(labelName);
  }

  var campaigns = AdsApp.campaigns()
    .withCondition("AdvertisingChannelType = 'PERFORMANCE_MAX'")
    .get();

  while (campaigns.hasNext()) {
    var c = campaigns.next();
    if (!c.labels().withCondition("Name = '" + labelName + "'").get().hasNext()) {
      c.applyLabel(labelName);
      Logger.log("Labeled: " + c.getName());
    }
  }
}

Why it matters: Labeling simplifies future script logic and bulk actions across PMax campaigns, especially in large accounts.

Advanced Tips for Scaling Scripts in Performance Max

Once you’ve mastered the basics of script installation and reporting, it’s time to think bigger. Whether you’re managing multiple PMax campaigns or running accounts at scale, these advanced strategies will help you streamline, automate, and extract more performance from your setup.

1. Leverage the Mutate Function for Complex Operations

The mutate function unlocks advanced Performance Max capabilities that traditional AdsApp methods don’t support:

Campaign Creation at Scale:

function createMultiplePerformanceMaxCampaigns() {
  const campaigns = [
    { name: "PMax - Region A", budget: 5000 },
    { name: "PMax - Region B", budget: 3000 }
  ];
  
  campaigns.forEach(campaignData => {
    const operation = {
      campaignOperation: {
        create: {
          name: campaignData.name,
          advertisingChannelType: "PERFORMANCE_MAX",
          campaignBudget: {
            amountMicros: campaignData.budget * 1000000
          }
          // Additional campaign settings
        }
      }
    };
    
    try {
      const result = AdsApp.mutate([operation]);
      Logger.log("Created: " + campaignData.name);
    } catch (error) {
      Logger.log("Error creating " + campaignData.name + ": " + error);
    }
  });
}

2. Asset Group Management Scripts

While individual asset modification isn’t possible, you can manage asset groups:

Asset Group Reporting:

function reportAssetGroupPerformance() {
  const campaigns = AdsApp.campaigns()
    .withCondition("AdvertisingChannelType = 'PERFORMANCE_MAX'")
    .get();
  
  while (campaigns.hasNext()) {
    const campaign = campaigns.next();
    const assetGroups = campaign.assetGroups().get();
    
    while (assetGroups.hasNext()) {
      const assetGroup = assetGroups.next();
      const stats = assetGroup.getStatsFor("LAST_7_DAYS");
      
      Logger.log("Asset Group: " + assetGroup.getName() + 
                " | Impressions: " + stats.getImpressions() +
                " | Cost: " + stats.getCost());
    }
  }
}

These reports pair nicely with CRO workstreams, especially when supported by structured CRO Audits.

3. Hybrid Automation Strategy

Combine scripts with other Google Ads features for maximum effectiveness:

• Scripts for monitoring, reporting, and basic campaign management
• Google Ads API for complex asset group operations
• Automated Rules for reactive changes based on performance
• Experiments for testing different strategies

This creates a hybrid control model, manual logic + automation without full loss of control, similar to how you’d blend Programmatic Advertising with search and social.

4. Error Handling for Performance Max Operations

Always include robust error handling, especially when using advanced functions:

function safePerformanceMaxOperation() {
  try {
    const campaigns = AdsApp.campaigns()
      .withCondition("AdvertisingChannelType = 'PERFORMANCE_MAX'")
      .get();
    
    // Your operations here
    
  } catch (error) {
    Logger.log("Error in Performance Max operation: " + error.message);
    // Optional: Send alert email
    MailApp.sendEmail({
      to: "[email protected]",
      subject: "Performance Max Script Error",
      body: "Error: " + error.message
    });
  }
}

This kind of safety net is just as important in automated media as it is in performance workflows that sit on top of Lead Generation Services.

When Not to Use Scripts for Performance Max (Updated)

1. Individual Asset Modification

Scripts still cannot modify individual creative assets like:

• Headlines, descriptions, images, or videos
• Asset combinations or performance insights at the creative level
• Creative rotation or A/B testing

Alternative: Alternative: Use feed-based approaches or the Google Ads interface for creative management, supported by Content Marketing and creative testing strategies.

2. Complex Campaign Creation Without Mutate

Avoid using traditional AdsApp methods for creating Performance Max campaigns:

// ❌ This won't work for Performance Max
const campaign = AdsApp.newCampaignBuilder()
  .withName("PMax Campaign")
  .build();

// ✅ Use this instead
const operation = {
  campaignOperation: {
    create: {
      // Campaign details using mutate function
    }
  }
};

3. Placement-Level Control

Scripts cannot:

• Block specific placements
• Limit visibility to specific networks (YouTube, Gmail, Discovery)
• Access detailed placement reports

Alternative: Use account-level exclusions or campaign settings during setup.

4. Smart Bidding Override

While you can monitor bidding performance, scripts cannot:

• Adjust Target CPA or Max Conversion Value
• Override automated bidding logic
• Implement manual bidding strategies

Alternative: Alternative: Use scripts for monitoring and alerting, but adjust bidding strategies through the interface and structured Search Engine Marketing (SEM) planning.

Troubleshooting Common Errors

Even well-written scripts can encounter errors, especially when applied to the more restrictive structure of Performance Max campaigns. Fortunately, most issues are fixable with a few tweaks.

Below are the most common problems (and how to solve them):

1. “Cannot Access Asset Group” or “AssetIterator Undefined”

What does it mean: Your script is trying to access ad group or asset-level data. This doesn’t work with PMax, since it uses asset groups, which are not accessible via scripts (as of 2025).

Fix:

Avoid referencing ad groups or creatives. Stick to campaign-level data only:

.withCondition("AdvertisingChannelType = 'PERFORMANCE_MAX'")

2. Script Doesn’t Return Any Data or Logs

What it means:

• Your filters may not match any campaigns
• Campaigns might be paused, removed, or excluded by the script’s logic.
• You may be previewing without proper date ranges.

Fix:

• Double-check that you have active PMax campaigns
• Confirm campaign names, types, and date ranges.
• Use Logger.log() to add checkpoints and test inside the script loop.

3. Authorization Errors (OAuth or API Access)

What does it mean: The script doesn’t have permission to access Sheets, send emails, or run scheduled jobs.

Fix:

• Re-authorize the script by clicking the “Authorize” button again.
• Ensure you’re logged into the correct Google account (with Ads + Sheets access)
• If using Sheets, confirm sharing settings and tab names match the script

4. Data Looks Incomplete or Outdated

What does it mean: You’re pulling data with a timeframe that hasn’t fully populated yet (e.g., “TODAY” at 8 AM), or conversion delays are causing underreporting.

Fix:

• Use stable timeframes like “YESTERDAY” or “LAST_7_DAYS”
• Always give PMax data 24–48 hours before pulling performance metrics.
• Avoid “TODAY” unless running late in the evening.

5. Labels or Sheet Rows Not Applying

What does it mean:

• The label doesn’t exist in the account
• The Google Sheet URL is invalid or unshared.
• Your script is trying to write outside of allowed cell ranges

Fix:

• Create the label manually or use a script to create it before applying.
• Double-check the sheet’s tab name and sharing permissions.
• Use sheet.clearContents(); or append rows to avoid overwrites

Advanced Tips for Scaling Scripts in PMax

Once you’ve mastered the basics of script installation and reporting, it’s time to think bigger. Whether you’re managing multiple PMax campaigns or running accounts at scale, these advanced strategies will help you streamline, automate, and extract more performance from your setup.

1. Use MCC-Level Scripts for Multi-Account Automation

If you manage multiple clients or business units, install scripts at the Google Ads Manager (MCC) level.

Benefits:

• Apply budget pacing, labeling, or reporting scripts across dozens of accounts.
• Consolidate campaign performance into a single Google Sheet.
• Monitor accounts for anomalies or overspending at scale.

Example MCC logic:

function main() {
  var accountSelector = MccApp.accounts();
  accountSelector.executeInParallel("processClientAccount", "logResults");
}

function processClientAccount() {
  var campaigns = AdsApp.campaigns()
    .withCondition("AdvertisingChannelType = 'PERFORMANCE_MAX'")
    .get();
  // Your custom logic here
}

2. Use Labels to Segment PMax Logic

For example:

• “PMax–Test” for experimental campaigns
• “PMax–HighBudget” for those spending over $5,000/month
• “PMax–Exclude” to skip specific campaigns in automation

Then structure your script around label logic:

if (campaign.labels().withCondition("Name = 'PMax–Test'").get().hasNext()) {
  // Apply different rules here
}

3. Pair Scripts with Automated Rules or Experiments

Use scripts for monitoring and reporting, and layer in:

• Automated rules for reactive changes (e.g., pause campaigns at 9PM)
• Experiments for creative testing, budget splits, or feed variations

This creates a hybrid control model, manual logic + automation without full loss of control.

4. Integrate Scripts with Google Ads API (Optional)

For deeper customization:

• Use scripts to flag data
• Use the API (via Python or Node.js) to modify feed-based assets, labels, or campaign structure.
• Connect with CRMs, Slack, or BigQuery for advanced workflows.

Scripts are ideal for light automation. For complete control, the API provides more options, but at the expense of increased complexity.

5. Build Custom Alerts with Email or Slack Notifications

Use MailApp.sendEmail() to push:

• Daily performance summaries
• Alerts for overspending, drops in conversions, or spikes in CPC
• Reports on campaigns with zero conversions in 7 days

Bonus: Use Slack Webhooks for real-time messages to your team.

When Not to Use Scripts for PMax

Google Ads scripts are helpful, but they’re not a silver bullet. In the case of Performance Max (PMax), scripts operate with restrictions that make them ideal for specific tasks and ineffective, or even risky, for others.

Here’s when you should avoid using scripts with PMax campaigns:

1. To Modify Asset Groups or Creatives

Scripts can’t access or edit:

• Headlines, descriptions, images, or videos
• Asset combinations or performance insights
• Audience signals or customer lists

Why: Asset groups in PMax are managed exclusively through the UI or API. Scripts can’t optimize creative rotation or asset testing.

2. To Automate Creative Testing

Would you like to rotate ad copy or images every week? Scripts won’t help. You’ll need:

• Feed-based ad structures
• Google Ads Experiments
• Third-party platforms for creative scheduling

Tip: Use feed optimization or supplemental feeds if your PMax campaign relies on Merchant Center and dovetails with Ecommerce Marketing.

3. To Override Smart Bidding Strategies

You can’t use scripts to:

• Adjust Target CPA or Max Conversion Value
• Manually change bids at the keyword or asset level.
• Disable automated bidding logic.

PMax enforces Smart Bidding at the campaign level. Scripts can report on performance, but not control bid logic.

4. To Influence Placements or Networks

Scripts can’t:

• Block placements
• Limit visibility to YouTube, Gmail, or Discovery.
• Pull detailed placement reports for exclusions.

For this, use account-level exclusions or creative targeting settings during setup, not automation.

5. If You’re Not Actively Monitoring

Scripts run unattended, which means:

• Errors can go unnoticed
• Campaigns can be paused or flagged incorrectly.
• Inaccurate logic can cost thousands before being caught.

Rule of thumb: If you’re not reviewing logs, testing scripts, or validating data regularly, don’t automate sensitive controls.

FAQs – Google Ads Scripts for PMax

Final Thoughts – Automate What You Can, Monitor What You Can’t

Performance Max campaigns offer automation at scale, but often at the expense of visibility and control. That’s where scripts come in. While they won’t unlock every setting or override Smart Bidding, they give you the power to:

• Track spend
• Monitor campaign health
• Organize accounts
• Export actionable data

In short, scripts help you stay informed, even when PMax limits your control.

The best advertisers combine intelligent automation with active oversight. Use scripts as your eyes and ears, not your hands. And always test carefully before scaling.

The real power of PMax isn’t in blindly trusting automation.

It’s in building systems that watch what automation can’t.