Automatizzare Alpha Beta Struttura campagna Uso degli script AdWords

A+ A-
google-adwords-bigA3-1920

Ho letto un sacco di blog e articoli sulla struttura Beta campagna Alpha e come può migliorare le prestazioni generali del tuo account. Infatti, in un recente AMA con Optmyzr fondatore ed ex-Googler Fredrick Vallaeys su Reddit, ha avuto solo cose positive da dire su questo approccio per la gestione delle campagne.

Ho anche letto che molte persone credono che il mantenimento di una struttura come questa è ad alta intensità di manodopera e soggetto ad errori, se non si sta attenti. Che suona come una ricetta perfetta per gli script di AdWords. Quando ho fatto alcune ricerche sul tema, ho visto un paio di articoli citano gli script AdWords per risolvere questi problemi, ma non sono riuscito a trovare alcun codice effettivamente usato. Forse è là fuori da qualche parte, ma nel frattempo, ho pensato che avrei scritto la mia.

Alpha Beta Struttura campagna

Questa idea per le campagne Beta Alpha è stato originariamente proposto da David Rodnitzky del 3Q digitale. L'idea di base è che voi di avere una serie di campagne di “beta” sfruttando la corrispondenza generica per trovare nuove parole chiave, e una serie di corrispondenti campagne “alfa” che contengono parole chiave a corrispondenza esatta con una comprovata record di prestazioni. Non ho intenzione di descrivere la tecnica per intero qui, ma si può leggere tutto su di esso nella loro guida.

Ci sono alcune cose che gli script possono aiutare con se si decide di mantenere questo tipo di struttura della campagna. In primo luogo, è possibile automatizzare tirando i vincitori e vinti dalle tue campagne beta sulla base di una serie di criteri. Ci sono un paio di script là fuori che fare qualcosa di simile a questo già, quindi non dovrebbe essere troppo difficile.

Da tale elenco, è possibile automatizzare facilmente aggiungere i perdenti come negativi per le nostre campagne beta. È inoltre possibile creare uno script per applicare automaticamente i vincitori nelle campagne alfa come negativi alle campagne beta.

Per quanto riguarda i vincitori, è un po 'più difficile per automatizzare, quindi non coprirà che qui. Con convenzioni di denominazione, che si muovono tali parole chiave nel proprio gruppo di annunci e l'aggiunta di una serie di annunci di default non dovrebbe essere troppo difficile. Ma con tutta la collezione e negativo aggiungendo curato, si dovrebbe essere in grado di spendere più del vostro tempo ottimizzando i vincitori.

Suona come abbiamo un sacco di lavoro davanti a noi, quindi cerchiamo di iniziare.

Trovare Winners, Losers e dati Not Enough

Cominciamo con uno script per tirare il rapporto di query di ricerca e affettare i risultati in tre categorie: Winners, Losers, e non abbastanza dati. Nella parte superiore dello script, abbiamo bisogno di definire alcune impostazioni che dovrebbero essere abbastanza auto-esplicativo.

La parte critica è determinare i criteri di vincere e perdere. Come si può vedere, questi sono costituiti da un elenco di clausole che filtrare i risultati della relazione query di ricerca in modo che solo le parole chiave che corrispondono a tali criteri sono lasciati. È possibile utilizzare praticamente qualsiasi colonna dal report query di ricerca e qualsiasi operatore dal AWQL. L'altra cosa importante è fare in modo che le colonne che si utilizzano nei criteri sono nelle colonne per il report query di ricerca.

 / *******************************
 * Trova i Vincitori e vinti dalla 
 * Rapporto Rendimento termini di ricerca per 
 * Alpha Beta Strategia per la campagna.
 ******************************* /
// L'elenco degli indirizzi email per inviare il report.
// Ci sarà anche dare accesso editor per il foglio di calcolo di Google.
var NOTIFICA = [ 'your_email@example.com'];
// Il nome del report nel lettore di Google
var SPREADSHEET_PREFIX = 'AlphaBetaResults -';
// Questa stringa viene utilizzata per identificare le vostre campagne Beta.
// Assicurarsi che questa stringa si trova in tutti i vostri nomi di campagna Beta
var BETA_SUFFIX = '| Beta';
// Questo è il lasso di tempo utilizzato per calcolare le statistiche.
var REPORT_TIMEFRAME = 'IERI';
// Questa è la lista di colonne che verrà visualizzato nella 
// Vincitori e perdenti rapporto. Assicurarsi che tutte le colonne usate in
// i criteri di seguito sono elencate qui.
var REPORT_COLUMNS = [
  'CAMPAIGNNAME', 'AdGroupName',
  'KeywordTextMatchingQuery', 'MatchType', 'Query',
  'Impressioni', 'click', 'costo', 'ConvertedClicks'];
// Questo è l'insieme di criteri che verranno utilizzati per
// determinare i vincitori. Qualsiasi delle colonne numeriche
// dovrebbe funzionare qui. Questi sono solo esempi, a trovare ciò
// funziona per voi.
var WINNING_CRITERIA = [
  'Clic> 100',
  // Se si utilizza colonne di denaro, assicurarsi di rappresentarli in micro
  // https://developers.google.com/adwords/api/docs/guides/reporting-concepts#money
  'Costo <1000000', 'ConvertedClicks> = 5'
];
var LOSING_CRITERIA = [
  'Impressioni> 100',
  'Clic <5',   
  'ConvertedClicks = 0']; 

funzione main () {
   generateWinnersLosersReport ();
}

funzione generateWinnersLosersReport () {
  // Questa stringa sarà allegato alla relazione per creare un unico   
  // nome di ogni giorno. Se si esegue questo intra-day, è possibile aggiungere ore (HH) per   
  // per la stringa di formato. 
  var = dateString Utilities.formatDate (new Date (), 
                                        AdWordsApp.currentAccount (). GetTimeZone (), 
                                        'Yyyy-MM-dd HH');
  var Crits = [WINNING_CRITERIA, LOSING_CRITERIA];
  fogli var = [
    getSheet (SPREADSHEET_PREFIX + dateString, 'vincitori'),
    getSheet (SPREADSHEET_PREFIX + dateString, 'perdenti')
  ];
  // Prendete tutti i risultati prima. In questo modo siamo in grado di rimuovere i vincitori e vinti   
  // per mantenere quelli con "i dati non basta".
  var allResults = pullSearchQueryPerfReport (REPORT_TIMEFRAME, REPORT_COLUMNS, []);
  for (var i in crits) {
    Risultati var = pullSearchQueryPerfReport (
      REPORT_TIMEFRAME,
      REPORT_COLUMNS,
      crits [i]
    );
    writeResultsToSheet (risultati, fogli [i]);
    removeFromAllResults (allResults, risultati);
  }
  // Maneggiare il 'Not Enough dati' caso
  var = notEnoughDataSheet getSheet (SPREADSHEET_PREFIX + dateString, 'Not Enough Data');
  writeResultsToSheet (allResults, notEnoughDataSheet);
  SendEmail (fogli, DateString);
}

// Questa funzione tira il rapporto di query di ricerca e 
// formati che sia facile da inserire in un foglio di Google.
Funzione pullSearchQueryPerfReport (tempi, colonne, crit) {
  var reportName = 'SEARCH_QUERY_PERFORMANCE_REPORT';
  var reportQueryTemplate = 'Seleziona% s da% s dove% s durante% s';
  // Aggiungere un criterio in modo che noi guardiamo solo i dati provenienti da campagne Beta.
  crit.push ( "CAMPAIGNNAME CONTIENE ' "+ BETA_SUFFIX +"'");
  var reportQuery = Utilities.formatString (reportQueryTemplate, 
                                           columns.join ( ''), 
                                           reportName,
                                           crit.join ( 'E'), 
                                           lasso di tempo);
  var = reportIter AdWordsApp.report (reportQuery, {
      includeZeroImpressions: true
    }) Righe ().;
  Risultati var = [];
  while (reportIter.hasNext ()) {
    var fila = reportIter.next ();
    var rowArray = [];
    for (var i in colonne) {
      rowArray.push (riga [colonne [i]]);
    }
    results.push (rowArray); 
  }
  restituire risultati;
}

// Questa funzione scrive i risultati in un determinato foglio di calcolo
Funzione writeResultsToSheet (risultati, foglio) {
  if (results.length> 0) {
    var KeywordIndex = REPORT_COLUMNS.indexOf ( 'KeywordTextMatchingQuery');
    sheet.appendRow (REPORT_COLUMNS)
    for (var i nei risultati) {
      // se la parola chiave inizia con un segno più,
      // abbiamo bisogno di aggiungere un apostrofo in modo fogli google
      // non ottiene infastidito.
      if (risultati [i] [KeywordIndex] .indexOf ( '+') === 0) {
        Risultati [i] [KeywordIndex] = "'" + risultati [i] [KeywordIndex];
      }
      sheet.appendRow (risultati [i]);
    }
  }
}

// Questa funzione rimuove i risultati in toremove dai risultati
// nell'array allResults. Usato per rimuovere vincitori e vinti così 
// che tutto quello che abbiamo lasciato sono i "Dati insufficienti" query.
removeFromAllResults funzione (allResults, toremove) {
  var allResultsRowHash = {};
  for (var i in allResults) {
    var rowHash = Utilities.base64Encode (JSON.stringify (allResults [i]));
    allResultsRowHash [rowHash] = 1;
  }
  for (var i in toremove) {
    var rowHash = Utilities.base64Encode (JSON.stringify (toremove [i]));
    if (allResultsRowHash [rowHash]) {
      allResults.splice (i, 1);
    }
  }
}

// Invia il foglio di calcolo in una e-mail per le persone nel
// Notifica lista. 
funzione SendEmail (fogli, DateString) {
  var subjectLineTemplate = 'Alpha Beta Risultati -% s -% s';
  var subjectLine = Utilities.formatString (subjectLineTemplate,
                                           AdWordsApp.currentAccount (). GetName (),
                                           dateString);
  var bodyTemplate = 'Qui è un foglio di calcolo con il' +
                     'Vincitori e vinti per conto:% s: \ n \ n% s';
  var body = Utilities.formatString (bodyTemplate,
                                    AdWordsApp.currentAccount (). GetName (),
                                    fogli [0] .getParent () getUrl ()).;
  for (var i in comunicazione) {
    MailApp.sendEmail (NAME [i], subjectLine, corpo);
  }
}

// funzione di supporto per ottenere o creare un dato foglio 
// un foglio di calcolo. Quando si crea un nuovo foglio di calcolo, ma anche
// aggiunge le email nell'elenco di notifica come editor.
funzionare getSheet (spreadsheetName, SheetName) {
  var fileIter = DriveApp.getFilesByName (spreadsheetName);
  if (fileIter.hasNext ()) {
    var ss = SpreadsheetApp.openByUrl (fileIter.next () getUrl ().);
    var fogli = ss.getSheets ();
    for (var i in fogli) {
      if (fogli [i] .getName () == SheetName) { 
        fogli [i] .clear ();
        fogli ritorno [i]; 
      }
    }
    ritorno ss.insertSheet (nomefoglio);
  } altro {
    var ss = SpreadsheetApp.create (spreadsheetName);
    ss.addEditors (notifica);
    foglio var = ss.insertSheet (nomefoglio);
    ss.deleteSheet (ss.getSheetByName ( 'Foglio1'));
    ritorno foglio;
  }
}

Eliminando i poveri esecutori

Mi consiglia di eseguire lo script di cui sopra per un po 'per assicurarsi di avere i tuoi criteri impostati correttamente. Una volta che siete soddisfatti dei risultati, si può facilmente automatizzare il compito di eliminare esecutori poveri delle campagne Beta.

Il seguente codice si basa su quello che hai già e aggiungerà automaticamente gli esecutori poveri come esatta negativi partita alla campagna Beta corrispondente. Basta sostituire la funzione main () nello script precedente e aggiungere questo codice aggiuntivo.

 // Sostituire il principale dall'alto con questo.
// Creiamo la relazione prima, ma poi
// anche aggiungere i perdenti al gruppo di beta.
funzione main () {
  generateWinnersLosersReport ();
  addLosersToBetaGroup ();
}

// Questo codice tira perdenti dal dal 
// campagna Beta con gli stessi criteri di prima.
Funzione addLosersToBetaGroup () {
  var loserResults = pullSearchQueryPerfReport (
    REPORT_TIMEFRAME,
    REPORT_COLUMNS,
    LOSING_CRITERIA
  );
  if (loserResults.length> 0) {
    var campKwHash = transformSearchQueryResults (loserResults);
    var campaignNames = Object.keys (campKwHash);
    // Trova tutte le campagne Beta
    . Var = campIter AdWordsApp.campaigns () withCondition ( "Il nome contiene ' "+ BETA_SUFFIX +"'") get ().;
    while (campIter.hasNext ()) {
      var = campo campIter.next ();
      var campName = camp.getName ();
      // Se la campagna è nella lista delle campagne Beta di cui abbiamo bisogno
      // aggiungere negativo
      if (campaignNames.indexOf (camp.getName ())> = 0) {
        var negativesList = campKwHash [campName];
        for (var i in negativesList) {
          // Aggiungere i negativi.
          camp.createNegativeKeyword (negativesList [i]);
        }
      }
    }
  }
}

// Questa funzione trasforma i dati del rapporto Query di ricerca
// in una mappa di {campaignname: [ "[Query1]", "[interrogazione2]", ...]}
transformSearchQueryResults funzione (risultati) {
  var campKwHash = {};
  var campColumn = REPORT_COLUMNS.indexOf ( 'CAMPAIGNNAME');
  var = queryColumn REPORT_COLUMNS.indexOf ( 'query');
  for (var i in loserResults) {
    fila var = loserResults [i];
    var campName = row [campColumn];
    var query = row [queryColumn];
    if (! campKwHash [campName]) {
      campKwHash [campName] = [];
    }
    campKwHash [campName] .push ( '[' + interrogazione + ']');
  }
  tornare campKwHash;
}

Protezione della Alpha query

L'ultimo aspetto della struttura Beta campagna Alpha possiamo automatizzare è assicurarsi che le sue campagne Alpha sono protetti. Non vogliamo che coloro corrispondenza esatta Alpha parole chiave avete lavorato così duramente su come ottimizzare presentarsi in una qualsiasi delle nostre campagne Beta.

Questo script può essere eseguito in modo indipendente del nostro script precedente. Si passerà attraverso tutti i tuoi Alpha Campagne e automaticamente aggiungere eventuali nuove parole chiave che trova come esatta negativi partita alla campagna Beta corrispondente. È possibile pianificare questo script da eseguire ogni ora sul tuo account, in modo che le sue campagne alfa e beta non saranno mai fuori sincronia.

 / *******************************
 * Aggiungi automaticamente eventuali nuove parole chiave nella vostra
 * Campagne alfa come esatta negativi partita in
 * Corrispondente campagna di Beta.
 ******************************* /
// Proprio come prima, queste stringhe saranno
// utilizzato per identificare l'Alfa e Beta campagne.
// Questo script presuppone che le sue campagne alfa sono
// il nome di "Nome campagna | Alpha" con la corrispondente
// campagna Beta denominata "Nome campagna | Beta"
var ALPHA_SUFFIX = '| Alfa';
var BETA_SUFFIX = '| Beta';

funzione main () {
  Risultati var = getKeywordReport ();
  var toupdate = {};
  for (var chiave nei risultati) {
    var campData = risultati [tasto];
    for (var i in campData.alpha.keywords) {
      var kw = campData.alpha.keywords [i];
      if (campData.beta.negatives.indexOf (kw) == -1) {
        if (! toupdate [campData.beta.campName]) {
          toupdate [campData.beta.campName] = [];
        }
        toupdate .push [campData.beta.campName] (kW);
      }
    }
  }
  . Var = campIter AdWordsApp.campaigns () withCondition ( "Il nome contiene ' "+ BETA_SUFFIX +"'") get ().;
  while (campIter.hasNext ()) {
    var betaCamp = campIter.next ();
    var betaCampName = betaCamp.getName ();
    if (toupdate [betaCampName]) {
      var negativesToAdd = toupdate [betaCampName];
      for (var i in negativesToAdd) {
        betaCamp.createNegativeKeyword ( '[' + negativesToAdd [i] + ']');
      }
    }
  }
}

// Questa funzione utilizza il rapporto parole chiave e
// gli aspetti negativi della campagna riportano di costruire una lista
// delle parole chiave e negativi in ​​ogni campagna.
funzione getKeywordReport () {
  colonne var = [ 'CAMPAIGNNAME', 'criteri', 'IsNegative'];
  var reportQueryTemplate = "SELECT% s da% s" +
                            "DOVE IsNegative IN [true, false]" +
                            "E CAMPAIGNNAME CONTIENE '% s'";
  var alphaReportQuery = Utilities.formatString (reportQueryTemplate, 
                                                columns.join ( ''), 
                                                'KEYWORDS_PERFORMANCE_REPORT',
                                                ALPHA_SUFFIX);
  var betaReportQuery = Utilities.formatString (reportQueryTemplate, 
                                               columns.join ( ''), 
                                               'CAMPAIGN_NEGATIVE_KEYWORDS_PERFORMANCE_REPORT',
                                               BETA_SUFFIX);
  query var = [alphaReportQuery, betaReportQuery];
  risultati var = {};
  for (var i nelle query) {
    var = reportIter AdWordsApp.report (query [i], {
      includeZeroImpressions: true
    }) Righe ().;
    while (reportIter.hasNext ()) {
      var fila = reportIter.next ();
      if (row.CampaignName.indexOf (ALPHA_SUFFIX) == -1 &&
         row.CampaignName.indexOf (BETA_SUFFIX) == -1) {
        Continua;
      }
      var campType = (row.CampaignName.indexOf (ALPHA_SUFFIX)> = 0)? 'Alpha': 'beta';
      
      var cleanCampName = row.CampaignName.split (ALPHA_SUFFIX) [0];
      cleanCampName = cleanCampName.split (BETA_SUFFIX) [0];
      
      if (! risultati [cleanCampName]) {
        risultati [cleanCampName] = {
          alfa: {parole chiave: [], negativi: [], campName: ''},
          beta: {parole chiave: [], negativi: [], campName: ''}
        };
      }
      Risultati [cleanCampName] [campType] .campName = row.CampaignName;
      if (row.IsNegative == 'true') {
        Risultati [cleanCampName] [campType] .negatives.push (row.Criteria);
      } altro {
        Risultati [cleanCampName] [campType] .keywords.push (row.Criteria);
      }
    }
  }
  restituire risultati;
}

Wrapping Things Up

Quindi, una volta che hai questi script installato e funzionante negli account Beta Alpha, tutto quello che resta da fare per voi è concentrarsi sul rendere sicuro il vostro campagne alfa sono il meglio che possono essere. La segnalazione e negativi dovrebbero essere presi cura di.

Naturalmente, si deve sempre prestare molta attenzione a ciò che i vostri script stanno facendo e li controllare su base regolare per assicurarsi che le cose stanno ancora lavorando in modo corretto. Tutto ciò che apporta modifiche al tuo account dovrebbe essere visualizzato in anteprima molte volte prima di eseguirlo in maniera regolare. Potrebbe anche essere una buona idea di separare questi in tre script, in modo da poter eseguire e testare se necessario.


Le opinioni espresse in questo articolo sono quelle dell'autore del cliente e non necessariamente Search Engine Land. Autori del personale sono elencate qui.


Ads

Condividere