Thursday, May 10, 2018

Search marketing software company WordStream acquired by Gannett for $150M

WordStream, the paid search software company that helps advertisers manage their PPC campaigns, has been acquired by the Gannett Company for $150 million. The deal is $130 million in cash, plus up to an aggregate $20 million earnout payable in 2019 and 2020 based on achieving certain revenue targets, according to the announcement.

WordStream was founded by Larry Kim, a high profile personality in the search marketing industry, back in 2007. In August of 2008, the company was able to secure a $4 million Series A investment from Sigma Partners, and in 2010, it secured a $6M Series B investment led by Egan Managed Partners. The company currently has over 2,000 customers. Larry stepped down as CEO a year or so ago, but he remained on the board of directors.

“This acquisition marks another critical milestone in Gannett’s digital transformation, enhancing our ability to support businesses and agencies in our local markets with the intelligent, data-driven marketing solutions they need to drive growth,” said Robert Dickey, president and chief executive officer of Gannett. “WordStream’s technology, extensive data and analytics capabilities together with an experienced executive team will bring tremendous value to Gannett’s expanding digital marketing services business.”

“WordStream is very excited about the opportunity this acquisition provides our customers and employees,” said Howard Kogan, chief executive officer at WordStream. “We see tremendous opportunity to leverage our companies’ combined data, analytics and marketing technologies to enhance the capabilities that WordStream brings to the DIY market, thereby accelerating our ability to drive further success and growth for our customers.”

The post Search marketing software company WordStream acquired by Gannett for $150M appeared first on Search Engine Land.

Posted by at 8 comments:

Google Lens improvements ready visual search and AR for mainstream adoption

Google Lens, the company’s visual search tool, was announced last year at I/O for Google’s Pixel devices and later rolled out for iOS and other Android devices, awkwardly through the photos app. You could take a photo and then run Lens against the photo rather than through the camera in real time.

This year at Google I/O, Lens’ distribution is expanding to a range of new devices and directly through the camera app as intended. The company also announced some updates:

  • Lens can analyze text and provide explanatory pictures or background information. Google points out that this involves semantic understanding of meaning and context of words and phrases.
  • Lens will now show you lookalikes. You see shoes you like or furniture out in the world; Lens will get more information about that item (assuming recognition) but can now also show you lookalikes (see below).
  • Google also says that Lens now works in real time “just by pointing your camera.”
lens_clothing_inPhone.gif

In a related vein, Google Maps now has new Lens-like features. You can use the camera in navigation for improved walking directions and information about places. The same computer vision and machine learning technologies are behind these features in Lens and Maps, as well as a new app for the visually impaired called Lookout.

Together with Apple’s ARKit, what all this means is that augmented reality is poised to go mainstream, while virtual reality looks increasingly like a lucrative vertical or niche application.

The post Google Lens improvements ready visual search and AR for mainstream adoption appeared first on Search Engine Land.

Posted by at No comments:

Wednesday, May 9, 2018

SearchCap: Google Maps, ads, AMP & search updates

Below is what happened in search today, as reported on Search Engine Land and from other places across the web.

From Search Engine Land:

Recent Headlines From Marketing Land, Our Sister Site Dedicated To Internet Marketing:

Search News From Around The Web:

The post SearchCap: Google Maps, ads, AMP & search updates appeared first on Search Engine Land.

Posted by at 2 comments:

Google asking dissatisfied searchers to submit questions manually in the search results

Google has confirmed it’s testing a new feature in the search results that asks searchers to submit a more detailed question to the company directly in the search results box. The box says, “Get the answer that you’re looking for added to the web,” and it feeds the information to Google. In exchange, Google tells us it may pass the question along to content creators who may be able to publish articles on their properties to better answer these questions.

Google is looking to create more content that it can index and ultimately return to searchers, which will help more searchers find what they are looking for.

This feature was spotted by Manashjyoti Athparia and posted in an online forum. Here is his screen shot of the user interface for this “small scale experiment,” as Google put it to us:

A Google spokesperson told us that this is a “small scale experiment designed to continue surfacing high quality, relevant results for our users by supporting a healthy content ecosystem.” This surfaces when Google thinks the searcher is not finding what they are looking for. Then Google will “experiment with ways to highlight these questions to content creators who may be able to publish articles on their properties to better answer these questions.” One such way is demonstrated above.

Google added that the “goal is to enrich the entire web ecosystem and thereby improve search results for users who may search for the same question in the future.” Google said it does “not plan to create that content,” nor does the company plan to pay others to create the content. Google also told us it does “not share any information with third parties beyond the actual text of the question typed by the user into the box provided.”

After the user submits the question, the box thanks them and closes automatically. Nothing more is shown to the searcher. This is a screen shot of the “learn more” content for this box:

The post Google asking dissatisfied searchers to submit questions manually in the search results appeared first on Search Engine Land.

Posted by at 1 comment:

Save the date: SMX East returns to New York City in October


Search Engine Land’s SMX East search marketing conference is returning to New York City Oct. 23-25. If you’re involved in marketing, PR, social media or any other customer-facing activity, you owe it to yourself (and your company’s or client’s bottom line) to attend the show.

SMX East delivers cutting-edge tips and techniques you’ll put to work immediately to harness opportunities and cope with challenges. It’s your survival guide to the dynamic and tumultuous world of search marketing.

SMX East: Something for everyone

SMX East is one of the ehree large Search Marketing Expo events that Search Engine Land’s publisher, Third Door Media, runs each year in the United States. The others are SMX Advanced, which takes place in Seattle on June 11-13 (early bird rates expire Saturday, so register now!), and SMX West held in San Jose, California.

Whether you’re a web designer or developer, in public relations, advertising or traditional marketing, search is such a crucial marketing medium that you should maintain an ongoing education about it. And as organizations integrate online and offline marketing, it’s crucial to understand how search fits in with the “big picture,” not only contributing to enhanced brand exposure, but in many cases paying for itself via measurably improved ROI.

We’ll post the agenda, including our editorial sessions, the Learn With Google and Excel With Bing classroom experiences and in-depth preconference workshops early next month. Meanwhile, if you register today, you can take advantage of our lowest Super Early Bird Rates.

Looking forward to seeing you in NYC this fall!

The post Save the date: SMX East returns to New York City in October appeared first on Search Engine Land.

Posted by at No comments:

Google updates mobile-friendly test, rich results test tools to better support JavaScript sites

Google has updated the mobile-friendly test and the rich results test tools to support JavaScript sites better. Google posted on Twitter that you now will see rendered HTML, console log, exceptions and stack traces.

This means those who build sites in JavaScript, AJAX and other forms of JavaScript frameworks can better debug their sites with these tools.

Here is a screen shot from Google showing how the mobile-friendly test tool renders JavaScript:

The mobile-friendly test tool shows you how easily a visitor can use your page on a mobile device. While the rich results test shows you search results that go beyond the standard blue link, they may include a carousel, image or other non-textual user interface elements for your page.

Google also announced they have a session tomorrow at Google I/O named deliver search-friendly JavaScript-powered websites that they recommend you watch.

The post Google updates mobile-friendly test, rich results test tools to better support JavaScript sites appeared first on Search Engine Land.

Posted by at No comments:

A time-saving free script to keep Ad Grants accounts out of trouble


Google updated its policies for Grants accounts at the start of 2018 and introduced a 5 percent click-through rate (CTR) criterion that has to be met for two months in a row to keep accounts from being suspended.

With four full months of the new policy now behind us, I’ve heard a few cases of non-profits that lost all their free search advertising because they were not paying close enough attention to the new policy.

This seems like a perfect use case for an AdWords script that continuously monitors whether all the criteria are being met and alerts advertisers before they get slapped with an AdWords account suspension.

The beauty of scripts is that there are often already partial pieces of the solution out there that you can leverage to create the exact solution you need.

And that’s the case here, too.

There are plenty of audit scripts that answer questions about ad extension coverage, ad group sizes and declines in CTR performance. I was about to combine all these elements into a new script but then found that a client of my company Optmyzr, recently wrote a script that checks most elements of the new Grants policy.

I suggested a few tweaks to the code, and you can grab a copy of their code below to start running your own Ad Grants account audits.

A Google Ad Grants audit script

What’s needed to keep Ad Grants accounts from being suspended is a mix of account structure requirements and account performance.

The idea is that the structural requirements enforce best practices that should, in turn, make it easier to meet the 5 percent CTR performance threshold. Scripts can check both of these types of things regularly so that advertisers can focus on other tasks while resting easy that they’ll get notified if there are potential issues.

Here’s what is checked by the script and for those who are new to AdWords, a little bit of the rationale behind each of the policy requirements.

Account structure requirements

First I’ll cover the structural elements of an account that the script checks.

Campaigns must use geotargeting

Even nonprofits that operate in multiple markets should use geotargeting, a setting that’s maintained at the campaign level. Each campaign can target users located in or searching for something in different places.

Operating a single campaign that targets too many locations causes advertisers to forego the ability to craft different messaging for each region, and that’s detrimental to getting a good CTR.

For example, if your ads are to support a homeless shelter, it’s probably more likely you’ll sign up new volunteers who live within a short driving distance. People who live farther away may still want to support the shelter but are more likely to donate money than time.

By running two separate campaigns, it becomes possible to prioritize ads with different objectives depending on where the user is located.

Campaigns must have at least two ad groups

Once your campaigns are set up, it’s time to create at least two ad groups in each one.

Ad groups in AdWords search campaigns are where you specify which ads should be shown for different keywords. The more closely the text of the ad matches the keyword, the higher the chance a user will understand why the ad is relevant to them, click on it and help you inch closer to the 5 percent CTR threshold to keep the account running.

The rationale behind having multiple ad groups is that it forces advertisers to split up long keyword lists. When an ad group starts to have more than 20 keywords, chances are that there is an opportunity to split that up into multiple ad groups with different themes that could get a more finely tuned ad.

Two Sitelink extensions

Ad extensions are a way to add more information to ads. Sitelinks are about giving users multiple landing page options to choose from, which can be useful to promote lesser-known aspects of a non-profit or to help users more quickly find the right page when they see your ad when doing a brand search.

Ad extensions are a fantastic way to boost your CTR and help maintain the 5 percent threshold Google now requires. In fact, their requirement of adding just two sitelinks is probably a bit too low, given how much these can help boost performance.

As long as you have enough interesting and unique landing pages, I recommend adding at least four sitelinks. Below is an example of an advertiser using more than two sitelinks, and as you can see, it helps them be more relevant for a search on a generic query like “donate.”

Ad Groups must have at least two ads

It’s hard for even the best marketer to write the single best possible ad for every keyword so that’s why AdWords encourages advertisers to submit multiple ad variations. Their machine learning algorithms can then match the best one based on what they know about each user, like what searches they might have done leading up to the one that triggered your ad.

Whether you’re doing ad testing manually, through a third-party tool or leaving it to Google with automatic ad optimization, having multiple ad variations is a must for any account.

Most one-word keywords are forbidden

The final requirement related to account structure is that no ad group should have single-word keywords unless they are the advertiser’s own brand or are on the exception list published by Google.

This is because these keywords tend to be overly generic and hence not very relevant to the majority of searchers. Even non-grants advertisers should be very careful about buying one-word keywords because these can have a high volume of queries that could quickly destroy the quality score of the account by racking up lots of impressions with very few clicks.

For example, if your non-profit is an animal shelter, the keyword “dogs” may seem relevant but the vast majority of people who type “dogs” in the search box are not looking to make a donation or volunteer at their local shelter. Better keywords would be multiword keywords like “volunteer work with dogs” or “dog shelter near me.”

One nice benefit of the script below is that it allows one-word keywords from several languages and has compiled them so that this script will work equally well in English as in many other languages.

Performance requirements

Next, the script also checks that performance requirements are met.

No keywords should fall below Quality Score (QS) 3

If all the structural requirements have been followed, meeting the performance requirements should become easier, like having at least a quality score of 4 for all keywords. Quality Score is Google’s assessment of the relevance of a keyword, so make sure to stay away from keywords that are too broad or that could mean different things to different people.

Account CTR must be at least 5%

All the requirements ultimately boil down to helping Ad Grants advertisers write relevant ads that Google’s users will like, and that’s measured through the account-level CTR.

The 5 percent threshold is pretty arbitrary, especially since Google doesn’t say this is a position-weighted CTR. This is an important distinction because ads that consistently show at the top of the page should easily get more than a 5 percent CTR, whereas ads rarely shown on page 1 may struggle to reach even a 2 percent CTR. So let me share a trick to help boost the rank of your ad which should help make the 5 percent threshold easily attainable.

A trick for meeting the minimum CTR threshold

Historically, it’s been challenging for Grants advertisers to be competitive with the $2 max cost per click (CPC) Google enforces for these accounts.

A $2 bid is often too low for the ad to rank on page 1 of the results, let alone at the top of that page, and that in turn causes big problems when trying to comply with the requirement that accounts maintain at least a 5 percent CTR for two consecutive months. But with the new policy, it’s possible to set higher CPCs by using the “Maximize for Conversions” automated bidding strategy.

But this bidding strategy is only available when there are at least 15 conversions for the past 30 days, and that can sometimes be hard to reach.

The simple workaround is to define a conversion as a click. Remember that with conversion tracking, the advertiser gets to pick what should be counted as a conversion. So, by simply counting a visit to the landing page as a conversion, you’re effectively calling each click a conversion, and now the threshold of getting 15 per month is very attainable.

With the maximize conversions bid strategy, Google will bid the right amount to get you as many clicks as possible, and in examples that we’ve heard from some of our clients, the effective average CPCs have been as high as $13, a big improvement over the $2 they were limited to in the past.

Conclusion

Auditing accounts can be time-consuming, but when your free Ad Grants money is in on the line, you absolutely have to stay on top of it.

Scripts are awesome for doing this routine, tedious task. So, rather than wasting precious hours digging through various reports and spreadsheets, now you can get all the results compiled in a spreadsheet and an email.

The script

Simply copy and paste this script into your Ad Grants account, make a copy of the spreadsheet where the results are compiled, and update the script with the uniform resource locator (URL) to that copy of your spreadsheet.

Then run the script to get a quick audit of how your account is doing. You’ll also get an email if you update the script with your email address.

/**********************************************************************************************************************
This Google Ads script checks a single Google grants account for mandatory requirements and logs the results in a Google Spreadsheet
UPDATED : 23.02.2024 : Updated to v16 api + updated the adgroup counting to consider DSA (thanks Frederique Boitelle for reporting this issue).
Author : Suisseo (Vincent Hsu)
More Info : https://www.suisseo.ch/en/blog/google-ad-grants-script/
1. Detect if Campaigns are set to 'maximize conversion' to allow bids higher that 2 dollars
2. Detect if each Campaign has at least 2 active ad groups with at least 2 active text (or at least 1 RSA)
3. Detect if each account has at least 2 active Sitelinks
4. Detect if each campaign has geo-targeting .
5. Detect Keywords that have a quality score under 3
6. Detect single keywords that are not branded or not in the authorized list
**********************************************************************************************************************/
//The url of the Spreadsheet
//Copy this template Google Spreadsheet in your Google Drive account : https://docs.google.com/spreadsheets/d/1rYif4Z9cTF1WmCRRl2w9vIOFy_ivs22_UpRP_qYHv08/copy
//You can change the name of the Spreadsheet, add Tabs, but do not change the names of the tabs in your Spreadsheet.
//Save the url of and paste it below
var SPREADSHEETURL = 'https://docs.google.com/spreadsheets/d/YOURSPREADSHEETKEY/edit#gid=0';
//Array of e-mails to which a notification should be sent every time the report is executed, comma separated
var ALERTMAILS = ['YOUREMAIL@YOURDOMAIN:COM'];
//list of branded single keywords that should not be taken into account (any single keyword that contains any of these will not be reported), comma separated
var BRANDEDKEYWORDS = ['YOURBRAND','ANOTHERBRANDEDKEYWORD'];
//include paused campaigns, ad groups and keywords in the reports can be set to true or false
var INCLUDEPAUSED = false;
var authorizedOneWordersArray = getAuthorizedSingleWords();
function main() {
runGrantsCheck()
}
function runGrantsCheck() {
const account = AdsApp.currentAccount().getCustomerId();
const SpreadsheetUrl = SPREADSHEETURL;
const campaignSums = checkCampaigns(SpreadsheetUrl);
const lowQSSum = getLowQualityKeywords(SpreadsheetUrl);
const oneWorderSum = getOneWorders(SpreadsheetUrl, BRANDEDKEYWORDS);
const ctr30Days = getAccountCtr(SpreadsheetUrl);
const totalCost30Days = AdsApp.currentAccount().getStatsFor("LAST_30_DAYS").getCost();
const access = new SpreadsheetAccess(SpreadsheetUrl, 'Abstract');
access.clearAll();
access.writeRows([
['Single keywords', 'Keywords with a quality \nscore smaller than 3', 'Campaigns with less \nthan 2 ad groups', 'Campaigns with \nno geo-targeting', 'Ad groups with less \nthan 2 active ads & no RSA', 'Campaigns with less \nthan 2 sitelinks', 'CTR 30 days'],
[oneWorderSum, lowQSSum, campaignSums[0], campaignSums[1], campaignSums[3], campaignSums[2], ctr30Days],['=HYPERLINK("https://www.suisseo.ch/en/blog/google-ad-grants-script/","To check for script updates visit : https://www.suisseo.ch/en/blog/google-ad-grants-script/")','','','','','','']
], 1, 1);
access.formatRows([
['#00ffff', '#00ffff', '#00ffff', '#00ffff', '#00ffff', '#00ffff', '#00ffff'],
['#ffff00', '#ffff00', '#ffff00', '#ffff00', '#ffff00', '#ffff00', '#ffff00']
], 1, 1);
const emailMessageTitle = "Suisseo Grants Report - " + AdsApp.currentAccount().getName() + " - " + account;
let emailMessageBody = "Your Google Grants report for the account : " + AdsApp.currentAccount().getName() + " - " + account + " is ready \n\n";
emailMessageBody += "Here's what we found : \n\n";
emailMessageBody += "Your CTR for the last 30 days is " + Math.round(ctr30Days * 100) / 100 + "%.\n";
emailMessageBody += "You spent " + Math.round(totalCost30Days*100) / 100 + "$ during the last 30 days.\n\n";
emailMessageBody += oneWorderSum + " Keywords with one word.\n";
emailMessageBody += lowQSSum + " Keywords with a quality score under 3.\n";
emailMessageBody += campaignSums[0] + " campaigns with less than 2 active ad groups.\n";
emailMessageBody += campaignSums[1] + " campaigns with no geo-targeting.\n";
emailMessageBody += campaignSums[3] + " ad groups with less than 2 active ads & no RSA.\n";
emailMessageBody += campaignSums[2] + " campaigns with less than 2 sitelinks.\n\n\n";
emailMessageBody += "Please visit this spreadsheet for more details: \n" + SPREADSHEETURL;
// if (new Date().getDay() == 3) {
sendSimpleTextEmail(emailMessageTitle, ALERTMAILS, emailMessageBody)
// }
}
function checkCampaigns(SpreadsheetUrl) {
const campaignTabName = 'Campaign Data';
const adGroupTabName = 'AdGroup Data';
let campaignRows = [];
// less than 2 ad groups, campaign geo, campaign sitelinks, ads per ad group
let inc = [0, 0, 0, 0];
let campaignFormatRows = [];
let adGroupRows = [];
let adGroupFormatRows = [];
let status = "Status = ENABLED";
if(INCLUDEPAUSED == true){ status = "Status != REMOVED";}
campaignRows.push(['CAMPAIGN NAME', 'BIDDING STRATEGY', "CONVERSIONS 30 DAYS", 'ACTIVE AD GROUPS', 'TARGETED LOCATIONS', 'CAMPAIGN SITELINKS', 'ACCOUNT SITELINKS']);
adGroupRows.push(['CAMPAIGN NAME', 'AD GROUP NAME', 'ENABLED ADS']);
const campaignIterator = AdsApp.campaigns()
.withCondition(status)
.forDateRange("LAST_30_DAYS")
.get()
while (campaignIterator.hasNext()) {
const currentCampaign = campaignIterator.next();
const campaignName = currentCampaign.getName();
//to check if it is set to 'MAXIMIZE_CONVERSIONS'
const campaignBiddingStrategy = currentCampaign.getBiddingStrategyType();
const campaignConversions = currentCampaign.getStatsFor('LAST_30_DAYS').getConversions();
const adGroupIterator = currentCampaign.adGroups()
.withCondition("Status = ENABLED")
.get();
//We need to check if the number of ad groups is greater or equal to 2 or if there is an RSA ad
const totalNumAdGroups = adGroupIterator.totalNumEntities();
//the location + the proximity number should be equal to 1 at least
const totalNumargetedLocation = currentCampaign.targeting().targetedLocations().get().totalNumEntities();
const totalNumargetedProximity = currentCampaign.targeting().targetedProximities().get().totalNumEntities();
const totalGeo = totalNumargetedLocation + totalNumargetedProximity;
const totalCampaignSitelinks = currentCampaign.extensions().sitelinks().get().totalNumEntities();
const totalAccountSitelinks = checkAccountSiteLinks();
// Red if not set to Maxime Conversions, green if set to Maximize Conversions
let campaignBiddingColor = '';
if ((campaignBiddingStrategy != 'MAXIMIZE_CONVERSIONS') ) {
campaignBiddingColor = '#f4cccc'
}
if ((campaignBiddingStrategy == 'MAXIMIZE_CONVERSIONS') ) {
campaignBiddingColor = '#d9ead3'
}
//Logger.log(campaignName + " : Bid : " + campaignBiddingStrategy + " : Ad groups in campaign : " + totalNumAdGroups + " Targeted Locations + Proximities : " + totalGeo + " Campaign Sitelinks : " + totalCampaignSitelinks );
campaignRows.push([campaignName, campaignBiddingStrategy, campaignConversions, totalNumAdGroups, totalGeo, totalCampaignSitelinks, totalAccountSitelinks]);
campaignFormatRows.push([' ',
campaignBiddingColor,
'',
totalNumAdGroups < 2 ? '#f4cccc' : '#d9ead3',
totalGeo < 1 ? '#f4cccc' : '#d9ead3',
totalCampaignSitelinks < 2 ? '#f4cccc' : '#d9ead3',
totalAccountSitelinks < 2 ? '#f4cccc' : '#d9ead3',
]);
if (totalNumAdGroups < 2) {
inc[0] += 1;
}
if (totalGeo < 1) {
inc[1] += 1;
}
if (totalCampaignSitelinks < 2 && totalAccountSitelinks < 2) {
inc[2] += 1;
}
//Lets check the number of ads in each ad group
while (adGroupIterator.hasNext()) {
const currentAdGroup = adGroupIterator.next();
const adsIterator = currentAdGroup.ads()
.withCondition("Status = ENABLED")
.get();
const adsIteratorRSA = currentAdGroup.ads()
.withCondition("Status = ENABLED")
.withCondition("ad_group_ad.ad.type IN (RESPONSIVE_SEARCH_AD)")
.get();
if (adsIterator.totalNumEntities() < 2 && adsIteratorRSA.totalNumEntities() == 0) {
const currentAdGroupName = currentAdGroup.getName();
inc[3] += 1;
//Logger.log("Ad group : " + currentAdGroupName + " : has less than 2 enabled ads and no RSA" )
adGroupRows.push([campaignName, currentAdGroupName, adsIterator.totalNumEntities()])
adGroupFormatRows.push(['', '',
'#f4cccc'
]);
}
}
}
let access = new SpreadsheetAccess(SpreadsheetUrl, campaignTabName);
access.clearAll();
access.writeRows(campaignRows, 1, 1);
access.formatRows(campaignFormatRows, 2, 1);
access.freezeFirstRow();
access = new SpreadsheetAccess(SpreadsheetUrl, adGroupTabName);
access.clearAll();
access.writeRows(adGroupRows, 1, 1);
access.formatRows(adGroupFormatRows, 2, 1);
access.freezeFirstRow();
return inc
}
function getOneWorders(SpreadsheetUrl, branded) {
let incW = 0;
const singleWordTabName = 'Single Word';
let singleWordRows = [];
let singleWordFormatRows = [];
let status = "WHERE ad_group.status = 'ENABLED' AND campaign.status = 'ENABLED' AND ad_group_criterion.status = 'ENABLED' AND ad_group_criterion.negative = false ";
if (INCLUDEPAUSED == true) {
status = "WHERE ad_group.status != 'REMOVED' AND campaign.status != 'REMOVED' AND ad_group_criterion.status != 'REMOVED' AND ad_group_criterion.negative = false ";
}
singleWordRows.push(['CAMPAIGN NAME', 'AD GROUP NAME', 'KEYWORD']);
const report = AdsApp.report("SELECT ad_group_criterion.keyword.text, campaign.name, campaign.status, ad_group.name, ad_group.status, ad_group_criterion.status " +
"FROM keyword_view " +
status +
"AND segments.date during LAST_30_DAYS", {
apiVersion: 'v16'
});
// Logger.log( "One Worder Keyywords" )
const rows = report.rows();
while (rows.hasNext()) {
const row = rows.next();
let kwLength = countWords(row['ad_group_criterion.keyword.text']);
if (kwLength == 1) {
kwLength = countWords(row['ad_group_criterion.keyword.text'].replace(/[|&|\/|\\|#|,|+|(|)|\-|$|~|%|.|'|"|:|*|?|<|>|{|}|]/g, ' ').trim());
if (kwLength == 1) {
//Logger.log( row['ad_group_criterion.keyword.text'] + ' -> ' + row['CampaignName'] + ' -> ' + row['AdGroupName']);
let authorized = false
for (let i in authorizedOneWordersArray) {
if (authorizedOneWordersArray[i][0].toLowerCase() == row['ad_group_criterion.keyword.text'].toLowerCase().replace(/^\+/, '')) {
authorized = true;
//Logger.log(authorizedOneWordersArray[i][0]);
break
}
}
for (let p = 0; p < branded.length; p++) {
if (row['ad_group_criterion.keyword.text'].toLowerCase().replace(/^\+/, '').indexOf(branded[p].toLowerCase()) != -1) {
authorized = true;
//Logger.log(branded[p]);
break
}
}
if (authorized == false) {
singleWordRows.push([row['campaign.name'], row['ad_group.name'], row['ad_group_criterion.keyword.text']]);
singleWordFormatRows.push(['', '', '#f4cccc']);
incW += 1;
}
}
}
}
const access = new SpreadsheetAccess(SpreadsheetUrl, singleWordTabName);
access.clearAll();
access.writeRows(singleWordRows, 1, 1);
access.formatRows(singleWordFormatRows, 2, 1);
access.freezeFirstRow();
//Logger.log('Found ' + incW + ' Keywords with one word')
function countWords(str) {
return str.trim().split(/\s+/).length;
}
return incW
}
function getLowQualityKeywords(SpreadsheetUrl) {
const lowQsTabName = 'Low QS';
let lowQsRows = [];
let lowQsFormatRows = [];
let status = "WHERE ad_group.status = 'ENABLED' AND campaign.status = 'ENABLED' AND ad_group_criterion.status = 'ENABLED' AND ad_group_criterion.quality_info.quality_score <= 2";
if (INCLUDEPAUSED == true) {
status = "WHERE ad_group.status != 'REMOVED' AND campaign.status != 'REMOVED' AND ad_group_criterion.status != 'REMOVED' AND ad_group_criterion.quality_info.quality_score <= 2";
}
lowQsRows.push(['CAMPAIGN NAME', 'AD GROUP NAME', 'KEYWORD']);
let inc = 0;
const report = AdsApp.report("SELECT ad_group_criterion.keyword.text, campaign.name, campaign.status, ad_group.name, ad_group.status, ad_group_criterion.status, ad_group_criterion.quality_info.quality_score " +
"FROM keyword_view " +
status, {
apiVersion: 'v16'
});
//Logger.log( "Low Quality Keywords <=2" )
const rows = report.rows();
while (rows.hasNext()) {
const row = rows.next();
//Logger.log( row['ad_group_criterion.keyword.text'] + ' -> ' + row['campaign.name'] + ' -> ' + row['ad_group.name']);
lowQsRows.push([row['campaign.name'], row['ad_group.name'], row['ad_group_criterion.keyword.text']]);
lowQsFormatRows.push(['', '', '#f4cccc']);
inc += 1;
}
const access = new SpreadsheetAccess(SpreadsheetUrl, lowQsTabName);
access.clearAll();
access.writeRows(lowQsRows, 1, 1);
access.formatRows(lowQsFormatRows, 2, 1);
access.freezeFirstRow();
//Logger.log('Found ' + inc + ' Keywords with QS <= 2')
return inc
}
function getAccountCtr(SpreadsheetUrl) {
const ctrTabName = 'CTR';
let ctrRows = [];
let ctrFormatRows = [];
ctrRows.push(['CTR LAST 7 DAYS', 'CTR LAST 14 DAYS', 'CTR LAST 30 DAYS']);
const ctr7d = AdsApp.currentAccount().getStatsFor("LAST_7_DAYS").getCtr() * 100;
const ctr14d = AdsApp.currentAccount().getStatsFor("LAST_14_DAYS").getCtr() * 100;
const ctr30d = AdsApp.currentAccount().getStatsFor("LAST_30_DAYS").getCtr() * 100;
//Logger.log(ctr7d + ' : ' + ctr14d + ' : ' + ctr30d)
ctrRows.push([ctr7d, ctr14d, ctr30d]);
ctrFormatRows.push([ctr7d < 5 ? '#f4cccc' : '#d9ead3', ctr14d < 5 ? '#f4cccc' : '#d9ead3', ctr30d < 5 ? '#f4cccc' : '#d9ead3']);
const access = new SpreadsheetAccess(SpreadsheetUrl, ctrTabName);
access.clearAll();
access.writeRows(ctrRows, 1, 1);
access.formatRows(ctrFormatRows, 2, 1);
return ctr30d
}
function checkAccountSiteLinks() {
//check account Sitelinks
const accountSitelinkSelector = AdsApp.currentAccount().extensions().sitelinks()
const accountSitelinkIterator = accountSitelinkSelector.get();
const totalAccountSitelinks = accountSitelinkIterator.totalNumEntities();
//Logger.log("Total Account Sitelinks " + totalAccountSitelinks)
return totalAccountSitelinks
}
function SpreadsheetAccess(spreadsheetUrl, sheetName) {
this.spreadsheet = SpreadsheetApp.openByUrl(spreadsheetUrl);
this.sheet = this.spreadsheet.getSheetByName(sheetName);
this.writeRows = function(rows, startRow, startColumn) {
this.sheet.getRange(startRow, startColumn, rows.length, rows[0].length).
setValues(rows);
};
this.formatRows = function(rows, startRow, startColumn) {
if (rows[0]) {
this.sheet.getRange(startRow, startColumn, rows.length, rows[0].length).
setBackgrounds(rows);
}
};
this.getRows = function(startColumn, endColumn) {
const data = this.sheet.getDataRange().getValues();
return data
};
this.clearAll = function() {
this.sheet.clear();
};
this.freezeFirstRow = function() {
this.sheet.setFrozenRows(1);
};
}
//send e-mail
function sendSimpleTextEmail(title, emails, message) {
let recipients = '';
for (let key in emails) {
recipients += emails[key] + ',';
}
MailApp.sendEmail(emails.join(','),
title,
message);
}
//Get single keywords from Suisseo's Spreadsheet
function getAuthorizedSingleWords() {
let words = [];
const tabName = 'All'
const singleKwSheet = "https://docs.google.com/spreadsheets/d/1wmllliOrBtxAn-qhT9O7BfJMLKs7MAYt50wNgUkTBPw/edit#gid=0"
const access = new SpreadsheetAccess(singleKwSheet, tabName);
const data = removeDuplicateInMultiArray(access.getRows());
//for (i in data) {
// Logger.log(data[i][0]);
//}
return data
}
//Remove duplicates from first column in 2d array
function removeDuplicateInMultiArray(arr) {
let uniqueArray = [];
for (let i = 0; i < arr.length; i++) {
let found = false;
for (let z = 0; z < uniqueArray.length; z++) {
if (arr[i][0] == uniqueArray[z][0]) {
found = true;
break;
}
}
if (found == false) {
uniqueArray.push(arr[i]);
}
}
return uniqueArray
}
view raw Suisseograntsscript.js hosted with ❤ by GitHub

The post A time-saving free script to keep Ad Grants accounts out of trouble appeared first on Search Engine Land.

Posted by at No comments:
Subscribe to: Posts (Atom)