Implementing Automated Keyword Bid Management with Google Ads Scripts

Keyword bid management is a core concept of paid search campaign management. It’s effectively how cost is determined for each click driven by a campaign.

This fundamental concept has been less prioritized over the years as Google introduced automated bid models like maximize clicks and maximize conversions. But, the core principle is as important as ever – especially when applied to the overlap between paid search campaigns and organic content.

Background on Search Engine Marketing (SEM)

In search engine marketing, paid and organic search inevitably share territory. Even with unique keyword approaches, this overlap occurs due to:

  1. Both channels target the same customer base
  2. A finite number of keywords related to your product or service
  3. High value keywords require attention from both channels

In fact, it’s often advantageous to overlap on high-priority keywords. This dual-channel approach creates the most visibility within the SERPs and creates a stronger overall presence. The key is not to eliminate overlap, but to manage it.

An optimized SEM strategy focuses on identifying keywords where organic content already performs well, then adjusting paid search campaigns accordingly. This cross-channel optimization represents the most nuanced way to manage search marketing.

For deeper analysis on when to prioritize each channel in your SEM strategy, see SEO and Paid Search: Friends or Foes?

Background on Keyword Bid Management in SEM

Keyword management in SEO and paid search have uniquely different approaches:

  • SEO focuses on keyword topics, with little control over search queries
  • Paid search targets specific keywords, with robust control over search queries

This means in keyword overlap, paid search does the heavy lifting to control cannabilization (when paid search drives a click that organic search would have otherwise captured).

The method for doing so is contained in keyword bids. A lower bid equates to lower position on page, and less chance of driving a click.

See Google’s Ad Auction: The Problem with Target CPA for more info on bids in the auction.

The Difference in Bid Strategy

Bid strategy determines the signals that are considered within the ad auction. Expanded over the years, the core bid models in platforms like Google Ads or Bing Ads are:

  • Manual CPC: full manual control over bids, no intent signals included in auction
  • Maximize Clicks: automated control over bids, no intent signals included in auction
  • Maximize Conversions: automated control over bids, behavioral signals included in auction

Due to it’s focus on intent signals rather than simply a CPC bid, conversion optimized models can’t be control strictly by a CPC bid.

For this reason, we’ll take a look at how to control bids in Manual CPC and Max Clicks models to avoid competing with SEO efforts. This process can be done manually, or with a script as outlined in the next section.

Implementing Keyword Bid Automation Scripts in Google Ads

Manual control of bids including bid modifiers can be done manually per keyword (manual CPC) or at the ad group level (maximize clicks).

However, Google Ads allows for the use of scripts (javascript code) to automate the process.

Using Scripts to Manage Keyword Bids

Scripts are located in the Google Ads interface under ‘tools’ → ‘bulk actions’. They are able to automate tasks within the ad account using a combination of functions manually entered by the user.

This goal of these scripts is:

  1. Reads the organic position of specific keywords
  2. Adjusts keyword bid based on organic position

Step 1: Categorize your Organic Rankings:

  1. Keywords ranked 1 or 2
  2. Keywords ranked 3-7
  3. Keywords ranked 7+

Step 2: Adjust your Paid Search Bids

  1. Ranked 1 or 2: ↓ Reduce bids by 50%
  2. Ranked 3-7: ↓ Reduce bids by 10%
  3. Ranked 7+: ↑ Increase bids by 25%

This framework helps paid search complement your SEO efforts rather than compete with them.

Key Requirements:

  1. You need to use a manual CPC or max clicks bid model
  2. Your SEO strategy needs to be strong enough to achieve top rankings

We’ll take a look at two implementations aimed at Manual CPC bidding and Maximize Clicks bidding. Bid modifiers do not work with conversion optimization as bidding is based on user intent rather than simply a keyword search.

Manual CPC Keyword Bid Automation

With manual CPC, bids are adjustable per keyword making this a simple process of increasing or decreasing the bid based on whether you rank for it organically.

The parameters that are needed to set this up are:

  1. List of organic keywords and rank
  2. Desired bid modifiers
  3. Campaign name to apply changes
Manual CPC Bidding Script
function main() {
  // Configuration
  var CONFIG = {
    spreadsheetUrl: 'YOUR_SPREADSHEET_URL',
    columns: {
      keyword: 'A',
      organicPosition: 'B',
      lastUpdated: 'C'
    },
    
    // Bid modification rules
    bidModifiers: {
      position1to2: -0.4,    // Decrease bids by 50%
      position3to4: -0.15,   // Decrease bids by 15%
      position5to10: 0.15,   // Increase bids by 15%
      positionOver10: 0.3    // Increase bids by 30%
    },
    
    // Performance thresholds
    minImpressions: 20,
    minClicks: 2
  };
  
  // Initialize spreadsheet
  var sheet = SpreadsheetApp.openByUrl(CONFIG.spreadsheetUrl).getActiveSheet();
  
  // Get all enabled keywords with manual CPC bidding
  var keywordIterator = AdsApp.keywords()
    .withCondition("Status = ENABLED")
    .withCondition("CpcBid > 0") // This indicates manual CPC bidding
    .forDateRange("LAST_30_DAYS")
    .get();
  
  Logger.log("Starting bid adjustment process...");
  
  while (keywordIterator.hasNext()) {
    var keyword = keywordIterator.next();
    var stats = keyword.getStatsFor("LAST_30_DAYS");
    
    // Skip keywords with insufficient data
    if (stats.getImpressions() < CONFIG.minImpressions || 
        stats.getClicks() < CONFIG.minClicks) {
      Logger.log("Skipping keyword '" + keyword.getText() + "' - insufficient data");
      continue;
    }
    
    // Get keyword text
    var keywordText = keyword.getText();
    
    // Get organic position from spreadsheet
    var organicPosition = getOrganicPosition(sheet, keywordText);
    if (!organicPosition) {
      Logger.log("No organic position data for keyword: " + keywordText);
      continue;
    }
    
    // Calculate bid modifier
    var modifier = calculateBidModifier(organicPosition, stats, CONFIG.bidModifiers);
    
    // Apply bid adjustment
    try {
      var currentBid = keyword.bidding().getCpc();
      var newBid = currentBid * (1 + modifier);
      
      // Ensure bid stays within reasonable bounds
      newBid = Math.min(Math.max(newBid, currentBid * 0.5), currentBid * 2);
      
      keyword.bidding().setCpc(newBid);
      
      Logger.log("Adjusted bid for '" + keywordText + 
                "' from " + currentBid + " to " + newBid + 
                " (modifier: " + modifier + ")");
    } catch (e) {
      Logger.log("Error adjusting bid for keyword '" + keywordText + "': " + e);
    }
  }
}

function getOrganicPosition(sheet, keyword) {
  // Find keyword in spreadsheet
  var data = sheet.getDataRange().getValues();
  
  for (var i = 1; i < data.length; i++) {
    if (data[i][0] === keyword) {
      return parseInt(data[i][1]); // Organic position is in column B
    }
  }
  return null;
}

function calculateBidModifier(organicPosition, stats, modifierRules) {
  var baseModifier = 0;
  
  // Set base modifier based on organic position
  if (organicPosition <= 2) {
    baseModifier = modifierRules.position1to2;
  } else if (organicPosition <= 4) {
    baseModifier = modifierRules.position3to4;
  } else if (organicPosition <= 10) {
    baseModifier = modifierRules.position5to10;
  } else {
    baseModifier = modifierRules.positionOver10;
  }
  
  // Performance-based adjustments
  var performanceModifier = 0;
  var ctr = stats.getClicks() / stats.getImpressions();
  var convRate = stats.getConversions() / stats.getClicks();
  
  if (ctr > 0.1) {  // Good CTR
    performanceModifier += 0.05;
  }
  if (convRate > 0.05) {  // Good conversion rate
    performanceModifier += 0.05;
  }
  
  return baseModifier + performanceModifier;
}

The following fields need to be updated with respective information:

  1. Spreadsheet URL
  2. Campaign Name
  3. Bid modifier values (optional)

It’s aimed at lowering ad placement for keywords ranked 1 or 2 by decreasing the CPC bid by 50%. This will in turn give the organic search result more opportunity to attract clicks.

The same can be done for a maximize clicks strategy, with one slight modification.

Keyword Bid Automation for Maximize Clicks Strategy

The benefit in using a max clicks bid model is automated bid management. However, it removes bids at the keyword level so modifiers need to be added at the ad group level.

To ensure each keyword can be modified, the PPC campaign must have single keyword ad groups (SKAGs).

The code used will also be slightly different than before.

Maximize Clicks Bidding Script
function main() {
  // Configuration
  var CONFIG = {
    spreadsheetUrl: 'YOUR_SPREADSHEET_URL',
    campaignName: 'YOUR_CAMPAIGN_NAME',
    columns: {
      keyword: 'A',
      organicPosition: 'B',
      lastUpdated: 'C'
    },
    
    // Bid modification rules
    bidModifiers: {
      position1to2: -50,
      position3to4: -15,
      position5to10: 15,
      positionOver10: 30
    },
    
    // Performance thresholds
    minImpressions: 20,
    minClicks: 2
  };
  
  // Initialize spreadsheet
  var sheet = SpreadsheetApp.openByUrl(CONFIG.spreadsheetUrl).getActiveSheet();
  
  // Get all enabled ad groups from the specified campaign
  var adGroupIterator = AdsApp.adGroups()
    .withCondition("Status = ENABLED")
    .withCondition("CampaignName = '" + CONFIG.campaignName + "'")
    .get();
  
  Logger.log("Starting bid adjustment process for SKAGs in campaign: " + CONFIG.campaignName);
  
  var processedCount = 0;
  var skippedCount = 0;
  var adjustedCount = 0;
  
  while (adGroupIterator.hasNext()) {
    var adGroup = adGroupIterator.next();
    
    // Get the single keyword in this ad group
    var keywordIterator = adGroup.keywords()
      .withCondition("Status = ENABLED")
      .forDateRange("LAST_30_DAYS")
      .get();
    
    // Should only be one keyword per ad group in SKAG setup
    if (keywordIterator.hasNext()) {
      var keyword = keywordIterator.next();
      processedCount++;
      
      // Verify this is truly a SKAG
      if (keywordIterator.hasNext()) {
        Logger.log("Warning: Ad group '" + adGroup.getName() + "' has multiple keywords. Skipping as it's not a SKAG.");
        skippedCount++;
        continue;
      }
      
      var stats = keyword.getStatsFor("LAST_30_DAYS");
      var keywordText = keyword.getText();
      
      // Log performance data
      Logger.log("Keyword '" + keywordText + "' stats - Impressions: " + 
                stats.getImpressions() + ", Clicks: " + stats.getClicks());
      
      // Skip keywords with insufficient data
      if (stats.getImpressions() < CONFIG.minImpressions || 
          stats.getClicks() < CONFIG.minClicks) {
        Logger.log("Skipping keyword '" + keywordText + "' - insufficient data");
        skippedCount++;
        continue;
      }
      
      // Get organic position from spreadsheet
      var organicPosition = getOrganicPosition(sheet, keywordText);
      if (!organicPosition) {
        Logger.log("No organic position data for keyword: " + keywordText);
        skippedCount++;
        continue;
      }
      
      // Calculate bid modifier
      var modifier = calculateBidModifier(organicPosition, stats, CONFIG.bidModifiers);
      
      // Apply modifier to the ad group (effectively keyword-level in SKAG)
      try {
        var bidAdjustment = 1 + (modifier / 100);
        adGroup.bidding().setAdGroupBidAdjustment(bidAdjustment);
        
        Logger.log("Successfully adjusted bid for SKAG '" + adGroup.getName() + 
                  "' (keyword: '" + keywordText + "') to " + modifier + "%");
        adjustedCount++;
      } catch (e) {
        Logger.log("Error adjusting bid for SKAG '" + adGroup.getName() + "': " + e);
        skippedCount++;
      }
    }
  }
  
  // Log summary
  Logger.log("\nSummary:");
  Logger.log("Total keywords processed: " + processedCount);
  Logger.log("Keywords skipped: " + skippedCount);
  Logger.log("Successful adjustments: " + adjustedCount);
}

function getOrganicPosition(sheet, keyword) {
  // Find keyword in spreadsheet
  var data = sheet.getDataRange().getValues();
  
  for (var i = 1; i < data.length; i++) {
    if (data[i][0].toLowerCase() === keyword.toLowerCase()) {
      return parseInt(data[i][1]);
    }
  }
  return null;
}

function calculateBidModifier(organicPosition, stats, modifierRules) {
  var baseModifier = 0;
  
  // Set base modifier based on organic position
  if (organicPosition <= 2) {
    baseModifier = modifierRules.position1to2;
  } else if (organicPosition <= 4) {
    baseModifier = modifierRules.position3to4;
  } else if (organicPosition <= 10) {
    baseModifier = modifierRules.position5to10;
  } else {
    baseModifier = modifierRules.positionOver10;
  }
  
  // Performance-based adjustments (reduced thresholds)
  var performanceModifier = 0;
  var ctr = stats.getClicks() / stats.getImpressions();
  var convRate = stats.getConversions() / stats.getClicks();
  
  if (ctr > 0.05) {  // Lowered from 0.1
    performanceModifier += 5;
  }
  if (convRate > 0.02) {  // Lowered from 0.05
    performanceModifier += 5;
  }
  
  return baseModifier + performanceModifier;
}

Key Considerations

  • Update list regularly. If possible, once per week to ensure bid modifiers are up to date.
  • Make sure keywords prioritized in SEO campaign match paid search efforts.

Implementing Bid Automation in SEM Strategy

A cohesive search engine marketing strategy starts simply: choose a set of target keywords. From there, it becomes much more complicated – managing hundreds of keywords across both organic and paid channels can take a significant amount of time.

While the theory of keyword bid management is straightforward, the implementation requires careful consideration and technical precision. The Google Ads script approach outlined above provides an automated solution that:

  1. Monitors organic rankings (provided a list)
  2. Dynamically adjusts bids based on SEO performance
  3. Eliminates manual work required for large keyword sets

The days of changing individual keywords bids are long since passed. This technical approach to bid management represents the most nimble search marketing integration, efficiently spending ad dollars where they will have the most incremental impact.

Remember that the script is just a tool – the strategy behind when and how to adjust bids is what truly matters. Test different bid modification percentages based on your specific industry and competitive landscape to find the optimal balance between paid and organic visibility.

Leave a Comment

Your email address will not be published. Required fields are marked *