Google Ads MCC Scripts: Cross-Account Management Automation (2026 Guide)

If you manage one Google Ads account, you can check it manually.

You log in.

You check spend.

You check conversions.

You check disapprovals.

You check pacing.

You check search terms.

You check whether anything looks broken.

That is manageable.

If you manage 50 accounts, this becomes impossible.

Not difficult.

Impossible.

You cannot inspect every account properly every morning by hand.

Not if you also need to write strategy, speak to clients, review creative, analyse data, build landing pages, fix tracking and improve performance.

At agency level, manual checking does not scale.

You need MCC Scripts.

MCC means Manager Account.

An MCC script runs at manager account level and can process multiple child accounts from one place.

Instead of installing the same script in 50 accounts, you install one script at manager level.

The script loops through the selected accounts.

It checks the data.

It writes the results to a master report.

It sends alerts.

It tells you where to look.

This changes the way you manage accounts.

You stop checking everything manually.

You start managing by exception.

Green accounts can wait.

Red accounts need action.

That is the agency workflow.

In this "Mega-Authority" guide, we cover:

1. The Hierarchy: MCC vs Single Account logic.
2. The "Master Dashboard" Script: Budget pacing for 100 clients.
3. The "Safety Net" Script: Detecting zero-impression accounts.
4. Implementation: The executeInParallel function.

The goal is simple.

Scale your monitoring.

Protect your clients.

Save your time for work that actually improves performance.

---

Part 1: Theory - The Iterator

A normal Google Ads script runs inside one account.

It can access campaigns, ad groups, keywords, ads, budgets and reports inside that one account.

Single Account Script:

AdsApp.keywords().get()

An MCC script starts one level higher.

It can access managed accounts.

MCC Script:

AdsManagerApp.accounts().get()

The simple loop looks like this:

while (accountIterator.hasNext()) {
  const account = accountIterator.next();
  AdsManagerApp.select(account);

  // Account-level logic runs here
}

The MCC script opens Account 1, runs logic and saves data.

Then it opens Account 2, runs logic and saves data.

Then Account 3.

Then Account 4.

And so on.

The important difference is context.

Inside a child account, you use AdsApp.

At manager level, you use AdsManagerApp to select the account first.

This is the most common mistake.

People copy a single-account script into an MCC and wonder why it fails.

The script needs to know which child account to work on.

A simplified sequential MCC pattern looks like this:

function main() {
  const accountIterator = AdsManagerApp.accounts()
    .withCondition("LabelNames CONTAINS 'Script_Active'")
    .get();

  while (accountIterator.hasNext()) {
    const account = accountIterator.next();

    AdsManagerApp.select(account);

    const accountName = account.getName();

    Logger.log("Checking account: " + accountName);

    const campaignIterator = AdsApp.campaigns()
      .withCondition("Status = ENABLED")
      .get();

    while (campaignIterator.hasNext()) {
      const campaign = campaignIterator.next();

      Logger.log(campaign.getName());
    }
  }
}

This is the basic mental model.

AdsManagerApp selects the account.

AdsApp works inside the selected account.

That is the hierarchy.

For small MCCs, sequential processing can be fine.

For larger MCCs, you may need parallel processing.

That is where executeInParallel comes in.

But do not rush there.

First understand the iterator.

Then optimise.

---

Part 2: The "Master Budget Pacing" Dashboard

The number one anxiety for agencies is budget pacing.

Will the client overspend?

Will the client underspend?

Will the campaign run out of budget too early?

Will the account miss the monthly target?

Will finance ask why spend is off?

You need one sheet that answers this every morning.

Not 50 separate accounts.

A proper master budget pacing report should show:

• Client Name
• Account ID
• Monthly Budget
• Spend So Far
• Expected Spend So Far
• Pacing %
• Projected Month-End Spend
• Remaining Budget
• Status

The Logic:

1. Script loops through all accounts with label Script_Active.
2. Fetches cost for THIS_MONTH.
3. Reads the monthly budget from a config sheet or account label.
4. Calculates expected spend by day of month.
5. Calculates pacing percentage.
6. Projects end-of-month spend.
7. Pushes row to a Google Sheet.

Benefit: You look at one screen in the morning.

If rows are green, you drink coffee.

If rows are red, you take action.

A pacing dashboard is not complicated.

The power is consistency.

Every day, same data.

Every account, same format.

Every issue, visible quickly.

A simple pacing formula is:

Pacing % = Spend MTD / Expected Spend MTD

Where:

Expected Spend MTD = Monthly Budget * (Day of Month / Days in Month)

Example:

Client budget: £10,000

Day of month: 15

Days in month: 30

Expected spend: £5,000

Actual spend: £6,000

Pacing: 120%

That account is overpacing.

But pacing needs judgement.

Some accounts intentionally front-load.

Some campaigns spend more on weekdays.

Some ecommerce accounts spend more around payday.

Some seasonal businesses need uneven pacing.

So do not let the script make every decision.

Let it flag the issue.

The strategist decides the action.

A good pacing sheet should also have notes.

For example:

1. "Front-loaded for launch."
2. "Client approved extra spend."
3. "Budget reduced from 15th."
4. "Seasonal push this week."
5. "Hold spend until new landing page live."

Automation highlights.

Humans interpret.

That is the right balance.

---

Part 3: The "Zero Impression" Alarm

Sometimes accounts stop serving.

It happens.

Credit cards fail.

Billing issues appear.

Ads get disapproved.

Campaigns are paused by mistake.

Budgets are exhausted.

Tracking or final URLs break.

A client removes access.

A policy issue blocks delivery.

A shared budget stops campaigns.

A bulk edit goes wrong.

If you do not notice for three days, you look careless.

For local services, ecommerce and high-spend accounts, this can be serious.

The Script:

1. Check impressions for YESTERDAY.
2. If impressions equal 0 and the account is meant to be active.
3. Send an email alert: "CRITICAL: Account X has 0 impressions."

The alert should not fire for cancelled clients.

It should not fire for paused accounts.

It should not fire for seasonal accounts intentionally offline.

This is why labels matter.

Use an account label such as:

Script_Active

Only accounts with that label are checked.

You can also create labels such as:

1. Script_Active
2. Script_Paused
3. Seasonal
4. Do_Not_Check
5. Client_Cancelled
6. Billing_Hold

The script should only check the accounts that are supposed to be live.

A zero-impression alert should include:

1. Account name.
2. Account ID.
3. Yesterday impressions.
4. Yesterday spend.
5. Yesterday conversions.
6. Account status where available.
7. Campaign count.
8. Notes or link to the account.
9. Timestamp.
10. Suggested checks.

Suggested checks:

1. Billing.
2. Policy disapprovals.
3. Campaign status.
4. Budget status.
5. Account access.
6. Final URLs.
7. Bid strategy status.
8. Location targeting.
9. Ad approvals.
10. Shared budgets.

This kind of alert saves accounts.

Not because it is complicated.

Because it tells you quickly when something is wrong.

---

Part 4: Implementation - Setting it Up

Set up MCC scripts from the manager account, not the child account.

1. Login to your MCC.
2. Go to Tools -> Bulk Actions -> Scripts.
3. Click New Script.
4. Use AdsManagerApp.accounts() as your selector.
5. Authorise the script.
6. Schedule it daily or hourly depending on the job.

Use hourly scheduling only where it matters.

For example:

1. Zero-impression alerts.
2. Overspend alerts.
3. Broken URL checks on high-spend accounts.
4. Conversion drop checks.
5. Critical campaign monitoring.

Use daily scheduling for:

1. Budget pacing.
2. Weekly reports.
3. Search term exports.
4. Performance dashboards.
5. Account health checks.

Do not run every script hourly for no reason.

Scripts have limits.

Large MCCs need careful handling.

A good implementation process:

1. Build the script in a test MCC or on a small label set.
2. Apply the Script_Active label to one test account.
3. Run preview.
4. Check logs.
5. Check output sheet.
6. Add two more accounts.
7. Test again.
8. Add production accounts in batches.
9. Schedule only after successful manual runs.
10. Monitor errors for the first week.

Do not point a new script at 100 client accounts on day one.

That is not automation.

That is gambling.

---

Part 5: executeInParallel - The Agency Scale Function

Sequential loops are easy to understand.

But they can be slow.

If your MCC contains many accounts, a normal loop may time out before finishing.

That is where executeInParallel helps.

It allows a manager account script to process multiple child accounts in parallel.

This is useful for:

1. Budget pacing.
2. Account health checks.
3. Zero-impression alerts.
4. Link checking.
5. Reporting exports.
6. Anomaly detection.
7. Conversion tracking monitoring.

The basic pattern is:

function main() {
  const accountSelector = AdsManagerApp.accounts()
    .withCondition("LabelNames CONTAINS 'Script_Active'")
    .withLimit(50);

  accountSelector.executeInParallel(
    "processAccount",
    "afterProcessAllAccounts"
  );
}

function processAccount() {
  const account = AdsApp.currentAccount();

  const stats = account.getStatsFor("YESTERDAY");

  const result = {
    accountName: account.getName(),
    customerId: account.getCustomerId(),
    impressions: stats.getImpressions(),
    clicks: stats.getClicks(),
    cost: stats.getCost(),
    conversions: stats.getConversions()
  };

  return JSON.stringify(result);
}

function afterProcessAllAccounts(results) {
  const output = [];

  for (let i = 0; i < results.length; i++) {
    const result = results[i];

    if (result.getStatus() === "OK") {
      output.push(JSON.parse(result.getReturnValue()));
    } else {
      output.push({
        accountName: "ERROR",
        customerId: result.getCustomerId(),
        error: result.getError()
      });
    }
  }

  Logger.log(JSON.stringify(output, null, 2));
}

This is the key idea.

processAccount() runs inside each selected account.

afterProcessAllAccounts() collects the results.

You can then write those results to a Google Sheet.

That is how you build cross-account dashboards.

Be careful with limits.

Process accounts in batches where needed.

Do not assume one script can handle every account, every report and every output perfectly in one run.

A mature agency setup may use several scripts:

1. Daily budget pacing.
2. Daily anomaly alerts.
3. Weekly link checker.
4. Weekly disapproval checker.
5. Weekly search term exporter.
6. Monthly summary exporter.

Separate jobs are easier to debug.

They are also safer.

---

Part 6: Summary & Checklist

MCC scripts are how agencies scale account monitoring.

They should not replace strategy.

They should replace repetitive checking.

The best use cases are:

1. Budget pacing.
2. Zero-impression alerts.
3. Spend anomaly alerts.
4. Conversion drop alerts.
5. Link checking.
6. Disapproval summaries.
7. Account health dashboards.
8. Search term exports.
9. Label-based monitoring.
10. Client reporting data pulls.

Your Action Plan:

1. Install or build an MCC Budget Pacing script.
2. Install or adapt a Link Checker MCC script.
3. Label your accounts. Exclude cancelled clients using filters.
4. Build your morning workflow around the Master Sheet, not the Google Ads interface.

Scale your time, not your stress.

Here is the deeper checklist:

1. Use MCC scripts for monitoring before automated changes.
2. Filter accounts by label.
3. Never run scripts across all accounts without a safety filter.
4. Test on one account first.
5. Use preview mode where possible.
6. Write output to Google Sheets.
7. Send alerts only for meaningful issues.
8. Avoid noisy alerts that everyone ignores.
9. Document every script’s purpose.
10. Store script owner and last updated date.
11. Review logs weekly.
12. Respect execution limits.
13. Use executeInParallel only when needed.
14. Do not automate destructive actions without safeguards.
15. Build dashboards that support action, not just reporting.

Automation is not about doing more.

It is about seeing risk faster.

---

The "Anomaly Detector" - Your 9 AM Alert System

The most valuable MCC script checks every active client account's yesterday spend and conversions against the 4-week rolling average and emails a summary every morning.

Example alert output:

• Client B: Spent $0 yesterday, usually £500/day -> Possible credit card issue, campaign pause or policy problem.
• Client F: Spent £2,000 yesterday, usually £200/day -> Possible runaway broad match, budget change or tracking issue.
• Client K: Conversions dropped to 0, usually 12/day -> Possible tracking failure or landing page issue.
• Client M: CPC increased 80% -> Possible competitor pressure or keyword matching issue.

Without this, you may need hours to spot the problems manually.

With it, you see the exceptions quickly.

A good anomaly detector should compare:

1. Yesterday spend vs 28-day average.
2. Yesterday conversions vs 28-day average.
3. Yesterday impressions vs 28-day average.
4. Yesterday clicks vs 28-day average.
5. CPA movement.
6. CPC movement.
7. Conversion rate movement.
8. Impression drop.
9. Cost spike.
10. Conversion value drop.

But keep alerts practical.

Do not send a panic email because an account with 3 clicks had a 50% change.

Set thresholds.

For example:

1. Spend change greater than 50% and spend above £100.
2. Conversion drop greater than 70% and normal conversions above 5/day.
3. Zero impressions where normal impressions exceed 500/day.
4. CPA spike greater than 50% with enough volume.

Noisy scripts get ignored.

Useful scripts get read.

---

"Click-Monkey" vs. Strategist

If you manually log into 50 accounts every morning to check basic performance, you are using strategy time for admin.

The math is brutal:

50 accounts × 10 minutes each = 500 minutes.

That is more than 8 hours.

Every day.

And that is just basic checking.

It leaves little time for actual improvement.

MCC automation can reduce this to a 15-minute review of one sheet.

The other hours can go into:

1. Strategy.
2. Client communication.
3. Creative testing.
4. Landing page analysis.
5. Search term reviews.
6. Competitor research.
7. Tracking fixes.
8. Offer testing.
9. Reporting commentary.
10. Account restructuring.

The value of automation is not that it makes you lazy.

It gives you time to do the work that matters.

A good agency should not be proud of manual checking.

It should be proud of fast detection and smart action.

---

The Budget Pacer Sheet

The second critical MCC script outputs a Google Sheet updated daily with:

Conditional formatting:

• Red: over 110%
• Yellow: under 90%
• Green: on track

You see at a glance which clients are overpacing and may blow budgets early.

You also see which accounts are underpacing and may miss opportunity.

Management by Exception: Ignore green rows. Act on red and yellow.

But add context.

A red row is not always bad.

A yellow row is not always bad.

Examples:

1. Red may be intentional front-loading.
2. Yellow may be a paused campaign awaiting approval.
3. Red may be a one-day seasonal push.
4. Yellow may be weak demand.
5. Red may need budget increase approval.
6. Yellow may need target relaxation.

The sheet does not replace judgement.

It directs attention.

That is its job.

---

Label Selectors - Safety First

Never write an MCC script that iterates over all accounts without a safety filter.

Use labels.

// SAFE - only checks labelled accounts
const accountSelector = AdsManagerApp.accounts()
  .withCondition("LabelNames CONTAINS 'Script_Active'");

First, add the label Script_Active manually to the accounts you want the script to manage.

Then run.

Without this, a script with a bug could process accounts you did not intend to touch.

If the script only reads data, that may be annoying.

If the script makes changes, it can become a disaster.

The label is your circuit breaker.

Use multiple safeguards for scripts that change anything:

1. Account label filter.
2. Dry-run mode.
3. Preview logs.
4. Email confirmation.
5. Change limit.
6. Account allowlist.
7. Campaign label filter.
8. Maximum spend threshold.
9. Error handling.
10. Manual approval for destructive actions.

Note: MCC-level scripts use AdsManagerApp, not only AdsApp.

This is the single most common syntax error when adapting single-account scripts to MCC use.

---

Final Rule

Use MCC scripts first for visibility.

Then for alerts.

Then for reporting.

Only then for automated changes.

The more accounts you manage, the more valuable automation becomes.

But the more dangerous mistakes become too.

Build slowly.

Label everything.

Test carefully.

Monitor the output.

That is how MCC scripts become an agency advantage instead of a risk.