Automatically Exclude Placements With a Particular Domain

AdWords lets advertisers show ads on the Display Network (GDN) and while it has ways to target ads to show on specific domains, or to exclude specific domains, they don't have a wildcard placement exclusion feature. 

So if you want to show your ads on all relevant placements, except those with a Polish domain extension (.pl) or an extension like .org, you would need to monitor automatic placements and add exclusions every time you saw one with this extension.

The following script makes it possible to automate excluding placements when the domain includes a particular string.

Run this daily or weekly in your AdWords account to prevent accruing too many clicks from unwanted placements.

Enjoy!
Frederick Vallaeys
Co-Founder, Optmyzr.com

	/****************************
	* Add a Placement Exclusion When an Automatic Placement Contains the Text ...
	* Version 1.0
	*
	* Created By: Frederick Vallaeys
	* for FreeAdWordsScripts.com
	* at the request of an Optmyzr.com subscriber
	****************************/
	function main() {
	var currentSetting = new Object();
	// The list of text strings to check in placement domains. If the placement domain contains ANY of these,
	// we WILL attempt to exclude it from the campaign
	currentSetting.stringsToExclude = new Array(
	"pets",
	".org"
	)
	// -- Most users should not have to edit anything after this
	currentSetting.dateRange = "LAST_30_DAYS";
	var DEBUG = 0;
	currentSetting.matchedCampaigns = new Array();
	currentSetting.reportType = "AUTOMATIC_PLACEMENTS_PERFORMANCE_REPORT";
	currentSetting.metricsColumns = ['DisplayName',
	'Domain',
	'IsPathExcluded',
	'CampaignName',
	'CampaignId',
	'AdGroupName',
	'AdGroupId',
	'Impressions',
	'Clicks',
	'Cost',
	'CostPerConversion'
	];
	currentSetting.whereConditions = ['WHERE',
	'Impressions', '>=', 1
	];
	var columnsUsedArray = currentSetting.metricsColumns;
	var columnsStr = currentSetting.metricsColumns.join(',');
	if(currentSetting.whereConditions.length > 0) {
	var whereClause = currentSetting.whereConditions.join(" ");
	} else {
	var whereClause = '';
	}
	var query = 'SELECT ' + columnsStr + ' ' +
	'FROM ' + currentSetting.reportType + ' ' +
	whereClause + ' ' +
	'DURING ' + currentSetting.dateRange;
	//Logger.log("query: " + query);
	var report = AdWordsApp.report(query);
	var reportIterator = report.rows();
	var numResults = 0;
	while(reportIterator.hasNext()){
	var row = reportIterator.next();
	var displayName = row['DisplayName'];
	var domain = row['Domain'];
	var campaignId = row['CampaignId'];
	var isPathExcluded = row['IsPathExcluded'];
	// Only add negative placements that aren't already excluded
	if(isPathExcluded == "false") {
	var result = containsAny(displayName, currentSetting.stringsToExclude);
	if(result) {
	if(DEBUG) Logger.log(displayName + " - " + domain);
	if(!currentSetting.matchedCampaigns[campaignId]) {
	currentSetting.matchedCampaigns[campaignId] = new Array();
	}
	currentSetting.matchedCampaigns[campaignId].push(domain);
	}
	}
	}
	for(var campaignId in currentSetting.matchedCampaigns) {
	var campaignExcludedPlacementCounter = 0;
	if(DEBUG) Logger.log("Campaign ID: " + campaignId);
	var campaignIdArray = new Array(campaignId);
	var campaign = AdWordsApp.campaigns().withIds(campaignIdArray).get().next();
	var campaignName = campaign.getName();
	Logger.log("For Campaign: " + campaignName);
	var matchedDomains = currentSetting.matchedCampaigns[campaignId];
	for(var i=0; i<matchedDomains.length;i++) {
	campaignExcludedPlacementCounter++;
	var domain = matchedDomains[i];
	Logger.log(" " + campaignExcludedPlacementCounter + ") excluding the domain: " + domain);
	var excludedPlacement = campaign.display().newPlacementBuilder().withUrl(domain).exclude().getResult();
	}
	Logger.log(" -> " + campaignExcludedPlacementCounter + " negative placements added to campaign " + campaignName + ".");
	Logger.log("");
	}
	function containsAny(str, substrings) {
	for (var i = 0; i != substrings.length; i++) {
	var substring = substrings[i];
	if (str.indexOf(substring) != - 1) {
	return substring;
	}
	}
	return null;
	}
	}

view raw Exclude Google Display Placements That Contain ... hosted with ❤ by GitHub

Get alerted when keywords or product groups spend too much

Automated Rules in AdWords are great to set up alerts for when things spend too much without converting enough. But unfortunately these Automated Rules can only be run once per day, so they're not very useful if you want to get notified as soon as a keyword or product group exceeds your thresholds.

So here's a simple script that queries for keywords or product groups that have exceeded a specific amount of cost, and have fewer than a specified number of conversions to show for that cost.

It then emails the list of alerts to the user. The email can include deep links to AdWords to make it really easy to go and fix issues. If the instructions for the settings currentSetting.customerId, currentSetting.effectiveUserId, and currentSetting.ocid confuse you, check out an earlier post by Russ that explains deep linking to ad groups in AdWords in more detail.

Thanks,
Fred Vallaeys

	function main() {
	var currentSetting = new Object();
	// what do you want to check?
	currentSetting.entityToCheck = "product groups"; // valid options: keywords, product groups
	// How much cost is allowed before we alert?
	currentSetting.maxCost = 1;
	// Fewer than how many conversions before we alert?
	currentSetting.MinConversions = 2;
	// who should get email alerts?
	currentSetting.emailsToNotify = ["example@example.com"]; // comma separated list, e.g. "example@example.com", "example2@example.com"
	// what date range do you want to check?
	currentSetting.dateRange = "TODAY"; // usually 'TODAY'
	// add links to help fix alerts by setting the following 3 values.
	// Load a page in your AdWords account and copy the numerical values for each of these these parameters
	currentSetting.customerId = '__c from the url'; // grab the URL from a page in your AW account and look for the numbers behind __c=
	currentSetting.effectiveUserId = '__u from the url'; // grab the URL from a page in your AW account and look for the numbers behind __u=
	currentSetting.ocid = 'ocid from the url'; // grab the URL from a page in your AW account and look for the numbers behind ocid=
	// --- Advanced users can change the AWQL queries used to find alerts ---
	var costToCheck = currentSetting.maxCost * 1000000;
	switch(currentSetting.entityToCheck) {
	case "keywords":
	currentSetting.reportType = "KEYWORDS_PERFORMANCE_REPORT";
	currentSetting.metricsColumns = ['Criteria',
	'CampaignName',
	'CampaignId',
	'AdGroupName',
	'AdGroupId',
	'Impressions',
	'Clicks',
	'Cost',
	'CostPerConversion'
	];
	currentSetting.whereConditions = ['WHERE',
	'Cost', '>=', costToCheck, 'AND',
	'Conversions', '<', currentSetting.MinConversions ];
	break;
	case "product groups":
	currentSetting.reportType = "PRODUCT_PARTITION_REPORT";
	currentSetting.metricsColumns = ['ProductGroup',
	'CampaignName',
	'CampaignId',
	'AdGroupName',
	'AdGroupId',
	'Impressions',
	'Clicks',
	'Cost',
	'CostPerConversion'
	];
	currentSetting.whereConditions = ['WHERE',
	'PartitionType', '=', 'UNIT', 'AND',
	'Cost', '>=', costToCheck, 'AND', // cost is in micros so multiply the currency amount by 1,000,000, e.g. $1 -> 1000000
	'Conversions', '<', currentSetting.MinConversions ];
	break;
	}
	// --- Most people will not want to change the code after this ---
	var columnsUsedArray = currentSetting.metricsColumns;
	var columnsStr = currentSetting.metricsColumns.join(',');
	if(currentSetting.whereConditions.length > 0) {
	var whereClause = currentSetting.whereConditions.join(" ");
	} else {
	var whereClause = '';
	}
	var reportText = "Alert for " + currentSetting.entityToCheck + " " + whereClause + "\n";
	reportText += "During " + currentSetting.dateRange;
	reportText += "\nResults:\n";
	// Pull the report with the options defined
	var query = 'SELECT ' + columnsStr + ' ' +
	'FROM ' + currentSetting.reportType + ' ' +
	whereClause + ' ' +
	'DURING ' + currentSetting.dateRange;
	//Logger.log("query: " + query);
	var report = AdWordsApp.report(query);
	var reportIterator = report.rows();
	var numResults = 0;
	while(reportIterator.hasNext()){
	var row = reportIterator.next();
	numResults++;
	reportText += numResults + ". ";
	/*
	for(var i = 0; i < columnsUsedArray.length; i++){
	var key = columnsUsedArray[i];
	var data = row[key];
	//Logger.log("data: " + data);
	//Logger.log(key + ": " + data);
	reportText += key + ": " + data + " | ";
	}
	*/
	switch(currentSetting.entityToCheck){
	case 'keywords':
	reportText += row['Criteria'] + "(campaign: " + row['CampaignName'] + ") (ad group: " + row['AdGroupName'] + ")"
	var deepLink = "https://adwords.google.com/aw/keywords?campaignId="
	+ row['CampaignId']
	+ "&adGroupId="
	+ row['AdGroupId']
	+ "&channel=1"
	+ "&ocid=" + currentSetting.ocid
	+ "&__c=" + currentSetting.customerId
	+ "&__u=" + currentSetting.effectiveUserId;
	break;
	case 'product groups':
	reportText += row['ProductGroup'] + " (campaign: " + row['CampaignName'] + ") (ad group: " + row['AdGroupName'] + ")"
	var deepLink = "https://adwords.google.com/aw/productgroups?campaignId="
	+ row['CampaignId']
	+ "&adGroupId="
	+ row['AdGroupId']
	+ "&channel=3"
	+ "&ocid=" + currentSetting.ocid
	+ "&__c=" + currentSetting.customerId
	+ "&__u=" + currentSetting.effectiveUserId;
	break;
	}
	reportText += "\n" + deepLink;
	reportText += "\n";
	}
	Logger.log(numResults + " matches found\n");
	Logger.log(reportText);
	if(currentSetting.emailsToNotify) {
	sendEmailNotification("", currentSetting.emailsToNotify, numResults + " AdWords Alerts", reportText);
	}
	function sendEmailNotification(from, to, subject, body){
	var remainingQuota = MailApp.getRemainingDailyQuota();
	if(remainingQuota > to.length && to) {
	MailApp.sendEmail(to, subject, body)
	}
	}
	}

view raw Keyword or Product Group Spend Alerts hosted with ❤ by GitHub

Limit AdWords Overdelivery to Any Amount You Want

Google announced that daily budgets will now be able to overdeliver up to 100% rather than 20% as had been the case since the earliest days of AdWords.

Overdelivery allows Google to help advertisers meet monthly budget targets by making up for slow traffic days by spending more money on high volume days. They assume that advertisers will divide their monthly budget by 30.4, and set this as the daily budget. Then when there may not be a whole lot of traffic on Saturdays and Sundays, Google can exceed the daily budget on Mondays and Tuesdays when there might be more people looking for what the advertiser sells.

Here's Google's announcement:

To truly control budgets they way you need, you'll probably want to use tools, automations, and AdWords Scripts. Here's a very basic script that lets you enforce a more strict overdelivery for a campaign. The script assumes that your daily budgets are the baseline of what you'd like to deliver. Use the setting 'allowedOverdeliveryPercentage' to control a maximum spend for the day by setting a value between 0% and 100%. The script fetches every active campaign's daily budget and accrued cost for the day. If the cost exceeds the daily budget + the allowed percentage of overdelivery, it will label that campaign and pause it.

Important Notes:

• Remember to use another automation to re-enable all paused campaigns during the first hour of every day. You can look for campaigns that have the label set by the script and re-enable those. 
• The script can be run once per hour so you may still exceed the total cost until the next time the script runs. 
• The script doesn't deal with shared budgets.
• The script doesn't deal with shopping and video campaigns. Making it work for those is really easy, you just have to update the campaigns call to use the video and shopping methods for getting campaigns.

If you need more control over budgets, and you don't want to do any coding, consider our prebuilt scripts available as part of an Optmyzr subscription (Optmyzr is my company).

/******************************************
*
* Version 1.0 
* Created By: Frederick Vallaeys
* FreeAdWordsScripts.com
******************************************/

function main() {
  
  var allowedOverdeliveryPercentage = 0.2; // set percentage as decimal, i.e. 20% should be set as 0.2
  var labelName = "paused by overdelivery checker script";
  
  AdWordsApp.createLabel(labelName, "automatic label needed to reenable campaigns");
  
  var campaigns = AdWordsApp.campaigns()
   .withCondition("Status = ENABLED")
   .withCondition("Cost > 0")
   .forDateRange("TODAY");
  
  var campaignIterator = campaigns.get();
  
  while (campaignIterator.hasNext()) {
    var campaign = campaignIterator.next();
    var campaignName = campaign.getName();
    var budgetAmount = campaign.getBudget().getAmount();
    var costToday = campaign.getStatsFor("TODAY").getCost();
    
    if(costToday > budgetAmount * (1 + allowedOverdeliveryPercentage)) {
      Logger.log(campaignName + " has spent " + costToday + " which is more than allowed.");
      campaign.applyLabel(labelName);
      campaign.pause();
    } else {
      Logger.log(campaignName + " has spent " + costToday + " and can continue to run.");
    }
  }

}

How to Keep AdWords Scripts Running When the AdWords API Changes

The AdWords API is regularly updated by Google with their latest capabilities. While it's great not to have to wait too long to get access to new capabilities, it comes with a downside too: AdWords Scripts may stop working on the day Scripts switch to using a newer version of the API.

The reason is that new API version may rename or remove metrics and attributes. An AdWords Script that is not updated with these latest names will stop working. 

You can find the release dates of new API versions here and the table looks like this:

The release date is not always the date that AdWords Scripts start to use the newer version. As a result, it is very tricky to ensure that scripts you write continue to work. 

Luckily there is a solution and it's as simple as telling your script which API version it should use by including the optional apiVersion argument. 

A reporting call without the API version: 

var report2 = AdWordsApp.report(
     'SELECT AdGroupId, Id, KeywordText, Impressions, Clicks ' +
     'FROM   KEYWORDS_PERFORMANCE_REPORT ' +
     'DURING 20130101,20130301');

And that same call with the API version:

var report2 = AdWordsApp.report(
     'SELECT AdGroupId, Id, KeywordText, Impressions, Clicks ' +
     'FROM   KEYWORDS_PERFORMANCE_REPORT ' +
     'DURING 20130101,20130301', {
       apiVersion: 'v201605'
     });

By telling the script which API version to use, you guarantee that it will continue to work on the day that Google switches the default the a new version because you now control the switch that tells the script when your code has been updated and should start using a new API version.

You'll still need to do the migration at some point, but you'll have several months to do so. The sunset date in the table above indicates the final day that a script can use a particular API version. After that date, the old version will cease to work.

Note that you do NOT have to go through every API version. It's completely acceptable to skip a version if you don't need any of its capabilities. For example, say you were using v201609. Since it doesn't sunset until October 2, 2017, you could have waited for the release of v201708 on August 9, 2017, and skipped the 2 API versions in between.

The scripts in the Optmyzr Enhanced Scripts library handle all of these API transitions automatically for our users so if you'd rather not deal with API versions, it's a great solution to try. (Optmyzr is my employer)