Am 26.09.2025 hat unser Geschäftsführer Richard Stinauer auf dem OMT dazu einen Vortrag gehalten. Die gezeigte Präsentation könnt Ihr Euch hier herunterladen:

adtraffic – Richard Stinauer – OMT 2025 – Der einfache Einstieg mit Google Ads Scripts – Handout

Der Impulsvortrag richtete sich vor allem an Neulinge und Anfänger; Personen, die also noch gar nicht mit Google Ads Scripts gearbeitet haben oder bisher nur erste Gehversuche gewagt haben. Im Vortrag ging Richard Stinauer deshalb zunächst auf drei einfache Einstiegsmöglichkeiten ein:

• Integrierte Lösungen in Google Ads
• Google Ads Skriptvorlagen
• Fertige Skripte von Drittanbietern

Manche Anforderungen lassen sich mit fertigen Vorlagen nicht abbilden. In zweiten Teil der Präsentation mit dem Titel “Dein erstes eigenes Skript” zeigte Richard Stinauer auf, wie man auch ohne Kenntnisse in der Softwareentwicklung in das Thema Google Ads Scripts einsteigen kann. Neben Voraussetzungen und Referenzen erklärte er auch anhand eines sehr einfachen Code-Beispiels die grundsätzliche Logik eines Google Ads Scripts.

Im abschließenden dritten Teil seines Vortrags erläuterte Richard, wie KI beim Einstieg, sowie bei der Erstellung und beim Debuggen von Google Ads Skripten helfen kann. Dabei war ihm wichtig, zu erwähnen, dass KI zwar ein echter Produktivitäts-Booster sein und die Lernphase deutlich beschleunigen kann, andererseits aber auch gelegentlich falsche Antworten liefert und deshalb nicht das Verständnis ersetzt. Sein Fazit: KI gerne als Co-Pilot einsetzen, aber bitte nicht als Autopilot.

The post Der einfache Einstieg mit Google Ads Scripts appeared first on adtraffic.

GA4 ermöglicht die automatische Messung von Interaktionen mit auf der Webseite eingebundenen Videos, sofern ein Player mit JS API-Unterstützung verwendet wird. Bei der Verwendung anderer Video Player benötigt man einen Workaround mit EventListeners. Für den Google Tag Manager hat Julius Fedorovicius eine Anleitung auf AnalyticsMania veröffentlicht. Der nachfolgende Implementierungsvorschlag dient für Google Tags, die ohne Tag Manager eingebunden wurden.

Voraussetzung und Empfehlung

Auf der Webseite ist der Google Tag bereits implementiert. Eine Anleitung dazu findet sich in der Google Analytics-Hilfe. Wir empfehlen zudem die Verwendung eines Consent Management Tools.

Video auswählen und Variablen vorbereiten

Das Video-Element auf der jeweiligen Seite wird mit einem Selektor ausgewählt. Zur späteren Verwendung können z.B. die URL und der Titel des Videos in Variablen gespeichert werden.

const video = document.querySelector(“video”);

var videoUrl = video.currentSrc;
var videoTitle = video.title;

Zur Begrenzung des Trackings auf jeweils ein Event je Seitenaufruf werden zusätzliche Statusvariablen definiert. Bei erfolgtem Tracking wird die zugehörige Variable später auf “true” gesetzt.

var started = false;
var played10 = false;
var played25 = false;
var played50 = false;
var played75 = false;
var played90 = false;
var ended = false;

Innerhalb der Event Handler wird der Status dieser Statusvariablen abgefragt. Sofern das Event noch nicht getrackt wurde, wird ein Tracking-Aufruf an den Google Tag gesendet.

Der “Video Start” Event Handler und Standard Parameter

Für den Start eines Videos mit Übergabe des Titels und der URL sieht der Event Handler wie folgt aus:

video.addEventListener(“play”, (event) => {
    if (started === false) {
        gtag(‘event’, ‘video_start’, {
            ‘video_url’: videoUrl,
            ‘video_title’: videoTitle,
            ‘video_percent’: 0
        });
        started = true;
    }
});

Dabei können die zuvor definierten Variablen als zusätzliche Parameter angehängt werden. In GA4 werden folgende Bezeichnungen für die vordefinierten Dimensionen und Metriken verwendet: 

• video_current_time
• video_duration
• video_percent
• video_provider
• video_title
• video_url
• visible (boolesch)

Der “Video Progress” Event Handler

Das Event für den Fortschritt der Videowiedergabe wird vom Browser regelmäßig während der Wiedergabe gefeuert. Durch Abfrage der aktuellen Wiedergabezeit kann auf Basis der Gesamtlänge des Videos die prozentuale Wiedergabedauer berechnet werden. Das Tracking der gewünschten Einzelschritte kann in einem Event Handler zusammengefasst werden. In diesem Beispiel werden Tracking Events jeweils bei 10, 25, 50, 75 und 90 erreichten Prozent der Gesamtdauer an den Google Tag gesendet. Die Aktualisierung der korrespondierenden Statusvariablen verhindert ein mehrfaches Tracking der Fortschritte.

video.addEventListener(“progress”, (event) => {
    if (played10 === false & video.currentTime / video.duration >= 0.1) {
        gtag(‘event’, ‘video_progress’, {
            ‘video_url’: videoUrl,
            ‘video_title’: videoTitle,
            ‘video_percent’: 10
        });
        played10 = true;
    }
    if (played25 === false & video.currentTime / video.duration >= 0.25) {
        gtag(‘event’, ‘video_progress’, {
            ‘video_url’: videoUrl,
            ‘video_title’: videoTitle,
            ‘video_percent’: 25
        });
        played25 = true;
    }
    if (played50 === false & video.currentTime / video.duration >= 0.5) {
        gtag(‘event’, ‘video_progress’, {
            ‘video_url’: videoUrl,
            ‘video_title’: videoTitle,
            ‘video_percent’: 50
        });
        played50 = true;
    }
    if (played75 === false & video.currentTime / video.duration >= 0.75) {
        gtag(‘event’, ‘video_progress’, {
            ‘video_url’: videoUrl,
            ‘video_title’: videoTitle,
            ‘video_percent’: 75
        });
        played75 = true;
    }
    if (played90 === false & video.currentTime / video.duration >= 0.9) {
        gtag(‘event’, ‘video_progress’, {
            ‘video_url’: videoUrl,
            ‘video_title’: videoTitle,
            ‘video_percent’: 90
        });
        played90 = true;
    }
});

Der kombinierte Video Tracking Code

Dieser Code sollte analog zum Google Tag nur nach Zustimmung des Nutzers ausgeführt werden, um unnötige und fehlerhafte Aufrufe zu vermeiden.

The post Video Tracking ohne JS API und ohne Google Tag Manager appeared first on adtraffic.

Wichtige Trends & Erkenntnisse

1. Automatisierung macht den Unterschied

Ein großes Thema war die Automatisierung von Nachrichten und Interaktionen auf Instagram. Tools wie ManyChat helfen dabei, DMs zu automatisieren, um schneller auf Anfragen zu reagieren und Leads effizienter zu generieren. Natasha Willis und Amberlea Henriques demonstrierten, wie diese Tools eingesetzt werden können, um gleichzeitig persönlich und skalierbar zu kommunizieren – sei es durch einfache Chat-Flows oder komplexere Verkaufsfunnels.

2. Künstliche Intelligenz unterstützt bei der Content-Erstellung

KI spielt mittlerweile eine zentrale Rolle in der Inhaltserstellung. Caroline Flett und Phil Pallen zeigten, wie man mit Tools wie ChatGPT und Adobe Express den Prozess der Content-Produktion vereinfacht. Von der Textgenerierung bis zur Videoaufbereitung gibt es viele Möglichkeiten, durch KI zeitsparend Inhalte auf hohem Niveau zu erstellen.

3. Storytelling und Authentizität stehen im Vordergrund

Eine der wichtigsten Botschaften: Hebe dich durch echte Geschichten von der Masse ab. Valeria Lipovetsky und Tori Dunlap betonten, wie wichtig es ist, authentische Inhalte zu teilen und die Community aufzubauen, bevor man versucht, direkt zu verkaufen. Die Formel lautet: erst Mehrwert bieten, dann konvertieren.

4. Strukturierte Profile und optimierte Bios

Eine gut gestaltete Instagram-Bio ist der erste Eindruck, den ein Besucher bekommt. Sie sollte klar und überzeugend sein, mit einem ansprechenden Foto, einem aussagekräftigen Profilnamen und einer deutlichen Handlungsaufforderung. Caroline Flett und Whitney Bartlette gaben praktische Tipps, wie man die Bio so gestaltet, dass sie gleich Interesse weckt.

5. Unterhaltung schlägt Werbung

Greg Fass von Liquid Death zeigte, dass humorvolle und unterhaltsame Inhalte oft viel besser ankommen als klassische Werbung. Sein Rat: Zeig dein Produkt, ohne zu direkt zu verkaufen. Die Marke wurde erfolgreich, indem sie auf originelle und witzige Ideen setzte, die sich von Standard-Marketing abheben.

6. Schnelle Reaktionen und relevante Angebote

Stephanie Perozo Bello erklärte, dass schnelle Antworten (innerhalb von 5 Minuten) die Conversion-Rate drastisch erhöhen können. Es geht darum, Nutzer direkt abzuholen, sei es mit kostenlosen Inhalten, Angeboten oder schnellen Follow-ups. Solche Strategien halten die Zielgruppe aktiv und steigern das Vertrauen.

Event-Format und Plattform: Flexibilität und Vernetzung

Das Online-Format des Summits und die benutzerfreundliche Event-Plattform machten es für alle Teilnehmer einfach, sich Vorträge anzuschauen – entweder live oder später als Aufzeichnung. Besonders hilfreich waren die virtuellen Konferenzräume, in denen man sich mit Veranstaltern, Sponsoren, Speakern und anderen Teilnehmern vernetzen konnte. So entstanden viele wertvolle Kontakte und Austauschmöglichkeiten.

Ein besonderes Highlight: Die musikalische Untermalung während der Mittagspausen durch DJ Graffiti, der mit seinen energiegeladenen Beats für eine lebendige und motivierte Stimmung sorgte.

Fazit

Der Instagram Summit 2024 zeigte, dass Erfolg auf Instagram heute stark auf Automatisierung, KI-gestützte Tools und durchdachte Community-Strategien setzt. Egal ob Marke, Creator oder Social-Media-Manager – wer diese Trends aufgreift, kann Reichweite und Engagement auf authentische Weise steigern. Das Event war nicht nur informativ, sondern auch durch das interaktive Online-Format und die spannenden Sessions sehr zugänglich und inspirierend.

The post Instagram Summit 2024: Trends und Highlights im Überblick appeared first on adtraffic.

Sie retten, löschen, bergen oder schützen und jeder ist im Grunde froh, wenn er sie nicht braucht: Die Feuerwehren. Die Kameradinnen und Kameraden der insgesamt 21 Abteilungen der Freiwilligen Feuerwehren in München sorgen gar ehrenamtlich für unsere Sicherheit. Und das rund um Uhr. Allein die Abteilung Solln wird zu bis zu 120 Einsätzen pro Jahr alarmiert.

Unser Kollege Hannes ist schon lange Mitglied der Sollner Feuerwehr und hat im Sommer 2023 erfolgreich die Ausbildung zum Zugführer absolviert. Seinen Urlaubsantrag für den zweiwöchigen Lehrgang haben wir nach kurzer interner Rücksprache abgelehnt. Wir wollten nicht, dass Hannes seinen Erholungsurlaub für diese Fortbildung in seiner ehrenamtlichen Tätigkeit opfert. Deshalb haben wir ihn für die zwei Wochen freigestellt und seine Vertretung unter uns aufgeteilt.

Arbeitgeber können für solche Fälle einen sogenannten “Antrag auf Erstattung der fortgewährten Leistungen im Zusammenhang mit dem Feuerwehrdienst oder dem Dienst im Katastrophenschutz” einreichen. Unser Antrag wurde von der Stadt München zügig bearbeitet und bewilligt, was uns eine unverhoffte Ausgleichszahlung beschert hat.

Diese Zahlung und den Jahreswechsel haben wir zum Anlass genommen, der Freiwilligen Feuerwehr Solln eine Geldspende in Höhe von 2.024 Euro zukommen zu lassen. Solche Spenden verwenden die freiwilligen Feuerwehren beispielsweise zur Aufklärung und Brandschutzerziehung oder auch zur Ergänzung der technischen Ausrüstung. So haben in den letzten Jahren unter anderem ein elektrischer Lüfter und das Sperrwerkzeug ihren Weg ins Hilfeleistungslöschgruppenfahrzeug (HLF) der Sollner Feuerwehr gefunden. Auch für die Öffentlichkeitsarbeit, Anwerbung von neuen Mitgliedern und zur Unterstützung der Jugendfeuerwehren können solche Gelder verwendet werden.

Am 16.01.2024 hat unser Geschäftsführer Richard Stinauer (1.v.r.) im Sollner Feuerwehrhaus unseren Spendenscheck offiziell an den Vorstand des Fördervereins der Freiwilligen Feuerwehr Solln übergeben, der auch fast vollzählig anwesend war: Der Vorsitzende und Abteilungskommandant Christian Kindermann (3.v.l.), sein erster stellvertretender Vorsitzender und stellvertretender Abteilungskommandant David Plath (2.v.r.), Kassier Hannes Eifler (1.v.l.) und Schriftführerin Julia Holzheu (2.v.l.) haben sich sehr über die Zuwendung gefreut, die in dieser Form bislang offenbar ein Einzelfall ist.

Um das zu ändern, haben wir gemeinsam beschlossen, mit Beiträgen sowohl auf Seiten der Freiwilligen Feuerwehr Solln (Webseite / Instagram / Facebook) als auch auf unseren Seiten etwas die Werbetrommel für derartige Zuwendungen zu rühren. Für Fragen zum Prozedere stehen wir gerne zur Verfügung.

The post 2024 fürs Ehrenamt: Freiwillige Feuerwehr Solln appeared first on adtraffic.

Los geht’s

Um loszulegen, kannst du den Erweiterungscode von unserem GitHub-Repository herunterladen. Das Repository enthält auch eine Installationsanleitung, die dir bei der Einrichtung der Erweiterung in deinem Chrome-Browser hilft.

GA4 Tracking-Aufrufe loggen leicht gemacht

Der GA4 Tracking Logger fügt deinen Chrome Developer Tools ein benutzerdefiniertes Panel hinzu. Damit kannst du ganz einfach Google Analytics Tracking-Aufrufe auf der untersuchten Webseite überwachen und protokollieren. Ob du gerade eine Website testest, Probleme behebst oder das Nutzerverhalten analysierst – diese Erweiterung vereinfacht in jedem Fall das Erfassen wertvoller Tracking-Daten.

Wichtige Funktionen für effektives Tracking

1. Starten und Beenden des Loggers
   Mit einem Klick kannst du die Verfolgung von Tracking-Aufrufen starten und stoppen.
2. Stapelverarbeitung von URLs 
   Du kannst mehrere URLs als Liste eingeben. Das Tool verarbeitet sie nacheinander und erfasst die Google Analytics Tracking-Aufrufe innerhalb der ersten fünf Sekunden.
3. Export von geloggten Ereignissen
   Nach dem Loggen kannst du die erfassten Tracking-Ereignisse als CSV-Datei exportieren und analysieren. Diese Funktion erleichtert die Analyse und den Austausch der gesammelten Daten.

So funktioniert der GA4 Tracking Logger

Die Erweiterung erfasst Tracking-Aufrufe, die spezifische URL-Muster enthalten, automatisch und protokolliert die relevanten Daten. Diese Daten werden mit Zeitstempeln versehen, um sicherzustellen, dass du eine genaue Aufzeichnung hast. Mit einer benutzerfreundlichen Oberfläche und intuitiven Steuerelementen vereinfacht die Erweiterung den Prozess der Erfassung und Protokollierung, um dir Zeit und Aufwand zu sparen.

Fazit

Mit dem GA4 Tracking Logger hast du ein leistungsstarkes Werkzeug zur Hand, um das Verfolgen und Protokollieren von Google Analytics Tracking-Aufrufen zu vereinfachen. Diese Erweiterung vereinfacht den Prozess und liefert dir wertvolle Einblicke in das Nutzerverhalten und die Interaktion. Ob Entwickler, Marketer oder Analyst – dieses Tool kann deine Arbeitsweise verbessern und dir helfen, fundierte Entscheidungen auf Grundlage genauer Tracking-Daten zu treffen. Lade die Erweiterung herunter und beginne noch heute, deine Google Analytics Tracking-Daten optimal zu nutzen.

The post Vorstellung des GA4 Tracking Logger appeared first on adtraffic.

Vorwort

Google Ads Scripts

Jenseits von Filtern, Regeln und Bulk-Uploads bieten Dir Google Ads Scripts eine ungleich größere Auswahl an Möglichkeiten, die Prozesse bei der Überwachung und Optimierung Deiner Google Ads Kampagnen zu automatisieren. Auf der zugehörigen Developers Seite findest Du eine Einführung (Guides) und die Referenz (Reference) zu Google Ads Scripts, sowie viele Code-Beispiele (Examples) für einzelne Funktionen bzw. Abfragen und sogar einige fertige Komplettlösungen (Solutions). Letztere sind in der Regel einfach konfigurierbar und lassen sich so relativ leicht den jeweiligen Bedürfnissen anpassen.

Dein individuelles Problem

Die vorgenannten Beispiele decken schon eine ganze Reihe an Anwendungsfällen ab oder lassen sich durch mehr oder weniger geringfügige Änderungen entsprechend anpassen. Oft sind die Vorlagen aber doch zu weit weg von der eigentlich gewünschten Lösung. Das ist der Zeitpunkt, selbst Hand anzulegen und ein neues, eigenes Google Ads Script – sozusagen auf der grünen Wiese – zu erstellen.

Unser konkretes Beispiel

Google legt die Anzeigenausrichtung nach Standort und Sprache bekanntlich relativ flexibel aus:

Dadurch werden selbst bei sehr eingeschränkter regionaler Ausrichtung die Anzeigen auch auf fremdsprachigen Seiten mit ausländischen Top-Level-Domains ausgespielt, die in unserem Fall erwartungsgemäß schlechte Performance-Daten aufweisen.

Die Idee

Der Impuls für die Entwicklung einer Automatisierung kommt naturgemäß meistens aus dem operativen Account Management. Unser Kollege Robert erklärt im Interview, wie sich aus seinem Wunsch nach einer Lösung für sein konkretes Problem das Skript aus diesem Artikel entwickelt hat.

Richard: Hi Robert, kannst Du noch einmal kurz zusammenfassen, wie die Idee für eine automatisierte Lösung zum Ausschluss von Placements zustande gekommen ist?

Robert: Die Antwort ist relativ einfach: aus dem täglichen Doing heraus. Als Account-Manager war mir beim Reporting einiger neuer Display-Kampagnen in einem unserer Kunden-Accounts aufgefallen, dass besonders viele und auf den ersten Blick doch eher unpassende Placements im Report “Wo Anzeigen ausgeliefert wurden” aufgeführt wurden. So hatten sich auf der ersten Seite des Berichts eine Vielzahl an Placements mit Endungen wie .ru, .pl oder .hu angehäuft – Placements bzw. Domainendungen also, die zumindest zu einem guten Teil an der eigentlich adressierten Zielgruppe vorbeigehen dürften.

Richard: Hattest Du noch weitere Anhaltspunkte dafür, dass die besagten Placements eher ungeeignet sind, einmal abgesehen vom Umstand mit den unpassenden Top-Level-Domains?

Robert: Ja, tatsächlich war mir bei einem genaueren Blick auf einige der Placements auch deren konkrete Performance negativ aufgefallen. Dazu ein Beispiel:

Dieses Placement ist auch in anderen Display-Kampagnen immer wieder aufgetaucht und hatte dabei ähnlich “verdächtige” Kennzahlen ausgewiesen. Bei einer CTR von über 50% im Display-Netzwerk hatten hier bei mir als verantwortlicher Account-Manager sofort die Alarmglocken geläutet und das Placement musste raus.

Richard: Wie ging es dann weiter?

Robert: Ausgehend vom manuellen Placement-Ausschluss und der doch relativ großen Menge potenziell ungeeigneter Placements kam relativ bald die Frage auf, ob sich dieser Prozess denn nicht – zumindest in Teilen – automatisieren ließe. In meiner naiven Vorstellung konnte es doch nicht so schwer sein, Google mitzuteilen, dass wir gerne nur Placements mit Endungen wie beispielsweise .de, .org oder .com drinnen haben und andere eben ausschließen möchten. Der bis zu diesem Zeitpunkt manuell durchgeführte Placement-Ausschluss gestaltete sich vergleichsweise aufwändig, da hier jedes einzelne Placement einzeln eingetragen und bestätigt werden musste. Leider musste ich aber relativ schnell feststellen, dass ein pauschales Ausschließen von ungewünschten TLDs mit Bordmitteln von Google so nicht zu bewerkstelligen war – vermutlich weil auch nicht unbedingt gewünscht. 😉

Richard: Und dann ging es als Nächstes auch schon an die Recherche und ans gemeinsame “Scripten”?

Robert: Richtig. Die Idee war relativ schnell geboren und musste jetzt “nur” noch in ein entsprechendes Google Ads-Script gepackt werden. Dass sich dieses Skript, wenn einmal fertig, dann mit hoher Wahrscheinlichkeit auch gewinnbringend für andere Kunden-Accounts einsetzen ließe, war während des gesamten Prozesses eine schöne, zusätzliche kleine Motivationsspritze.

Richard: Wie zufrieden bist Du mit dem gemeinsamen Ergebnis?

Robert: Sehr zufrieden. Insbesondere auch deshalb, weil sich an die erste Version des Skripts sehr schnell eine zweite angeschlossen hat, die die erste direkt noch um eine Funktion für ein Whitelisting bestimmter, erwünschter Placements erweitert hat.

Richard: Könntest Du noch kurz erklären, was es damit auf sich hat?

Robert: Nach ca. einer Woche Arbeit mit der ersten Version des Skripts hat sich – erneut aus dem täglichen Doing heraus – schnell noch ein relativ wichtiger Punkt herauskristallisiert: es gibt eben doch auch Placements, die nicht auf die vertrauten TLDs enden, die aber dennoch bespielt werden sollen (ein schönes Beispiel dazu: “bedienungsanleitu.ng” – vermutlich schon einmal dem ein oder der anderen begegnet). So war also relativ schnell klar – wir brauchen eine Whitelisting-Funktion, um bestimmte Placements dauerhaft von einem automatischen Ausschluss ausnehmen zu können.

Richard: In drei Stichpunkten – was waren Deine wichtigsten Learnings aus dem gesamten Prozess?

Robert: (1) Die Erstellung von Google Ads-Scripts folgt einer interessanten Mischung aus gesundem Menschenverstand und purer Logik. (2) Grundlegende JavaScript-Kenntnisse vereinfachen die Erstellung zweifellos, man ist aufgrund der umfangreichen und ausführlichen Google-Dokumentation aber auch ohne solche Kenntnisse nicht komplett aufgeschmissen. (3) Google Ads-Scripts möchten sich von sich aus gerne “weiterentwickeln”, man muss ihnen nur ein wenig dabei behilflich sein… 😉

Richard: Vielen Dank für das Interview!

Der manuelle Prozess

Wie Robert im Interview beschrieb, wurden unerwünschte Placements bisher in der Ansicht “Wo Anzeigen ausgeliefert wurden” mittels Filter ausgewählt und als Placement-Ausschlüsse in der jeweiligen Kampagne ergänzt. Ein direktes Hinzufügen dieser Placements aus dieser Ansicht in eine gemeinsame Ausschlussliste ist nicht möglich – sie müssten händisch kopiert oder abgetippt werden.

Der Wunsch

Weil diese marktfremden Placements sinnvolle Ausschlüsse für mehrere, wenn nicht alle Kampagnen sind, sollten diese automatisiert in einer gemeinsamen Placement-Ausschlussliste gepflegt werden, die für alle betreffenden Kampagnen angewendet wird.

Die Lösung

Um die konkreten Anforderungen für unser eigenes Google Ads Script zu definieren, überlegen wir zunächst, wie wir den Prozess in einzelne Schritte zerlegen können:

Vorbereitung: Placement Ausschlussliste erstellen und für Kampagne(n) anwenden

Auch das könnte man automatisieren, wir haben uns aber dazu entschieden, diese Einmalaufgabe manuell zu erledigen.

1. Unerwünschte Placements erkennen
   Das Script soll zuerst eine Liste mit den Placements erstellen, die als Ausschluss in Frage kommen.
2. In Ausschlussliste ergänzen
   Sofern die unerwünschten Placements noch nicht ausgeschlossen sind, sollen sie in der Ausschlussliste ergänzt werden.
3. Bestätigung per E-Mail verschicken
   Nach der Ausführung soll das Script eine E-Mail mit den ausgeschlossenen Placements an den zuständigen Account Manager verschicken.

Die Recherche

Für jeden Prozessschritt werden wir eine Funktion oder Abfrage benötigen. Im Vorfeld recherchieren wir deshalb, welche Objekte innerhalb der Google Ads Script API dafür in Frage kommen:

1. Unerwünschte Placements erkennen
   Zur Abfrage von Daten aus Google Ads hält die API die Methode search(query, optArgs) bereit.
   Die Abfragen kann man in der Google Ads Query Language schreiben.
   Damit können eine ganze Menge an Datenquellen und -feldern abgefragt werden.
   Und es gibt einen Google Ads Query Builder, um diese Abfragen zu bauen.
   Auf den ersten Blick kommen drei Ressourcen für unsere Aufgabe in Frage:
   • Detail Placement View
   • Group Placement View
   • Managed Placement View
2. In Ausschlussliste ergänzen
   In der Google Ads Script API gibt es ein offenbar passendes Objekt mit der Bezeichnung AdsApp.​Excluded Placement List, mit dessen Methoden addExcludedPlacement und addExcludedPlacements einzelne oder auch mehrere Placements gleichzeitig zu einer Placement-Ausschlussliste hinzugefügt werden können.
3. Bestätigung per E-Mail verschicken
   Unter den Code-Beispielen auf der Google Ads Scripts Seite findet sich unter Utilities > MailApp das Snippet “Send a simple email”, das offenbar genau diesen Zweck erfüllt.
   

Die Erstellung

Nach Abschluss unserer Recherche können wir direkt mit der Erstellung des Script-Codes anfangen.

Neues Script anlegen

Dazu legen wir uns zuerst ein neues Skript im betreffenden Google Ads Account an. Zum Bereich “Skripts” gelangt man in Google Ads über die Header-Navigation durch Klicken auf “Tools und Einstellungen > Bulk-Aktionen > Skripts”. Ein neues leeres Skript wird durch Klick auf den blauen Plus-Button und die anschließende Auswahl der Option “Neues Skript” erstellt.

Das neu erstellte Skript fordert zunächst eine Autorisierung an, um später Änderungen im Namen des jeweiligen Nutzers vornehmen zu können.

Nach Klick auf “Autorisieren” kann man zunächst das gewünschte Konto auswählen und dem Skript dann die benötigten Zugriffe erlauben.

Dem Skript kann man auch gleich einen passenden Namen geben.

Jetzt kann es losgehen mit der Erstellung des Codes…

Funktion queryPlacementUrls()

Im ersten Schritt möchten wir unerwünschte Placements erkennen. Dazu schreiben wir uns eine Funktion, die uns ein sortiertes Array zurückgibt.

function queryPlacementUrls(){
  var placementUrls = [];
  return placementUrls.sort();
}

Um das Array zu füllen, erstellen wir uns mithilfe des Google Ads Query Builders zunächst den Code zur Abfrage der unerwünschten Placements in unserer/n Display-Kampagne/n.

In unserem Beispiel durchsuchen wir dazu alle aktiven und pausierten Kampagnen vom Typ “DISPLAY”, deren Name mit “GDN_” beginnt und fragen alle Placements vom Typ “WEBSITE” ab, die nicht auf eine der im Suchstring angegebenen Top-Level-Domains enden.

  var query = 
    "SELECT " +
    "  group_placement_view.target_url " +
    "FROM group_placement_view " +
    "WHERE " +
    "  campaign.status IN ('ENABLED', 'PAUSED') " +
    "  AND campaign.advertising_channel_type IN ('DISPLAY') " +
    "  AND group_placement_view.placement_type IN ('WEBSITE') " +
    "  AND group_placement_view.target_url NOT REGEXP_MATCH '.*\.(de|at|ch|com|net|org|info)' " +
    "  AND campaign.name REGEXP_MATCH '^GDN_.*$' " +
    ""
    ;
  var result = AdsApp.search(query, {apiVersion: 'v12'});

Das Ergebnis der Abfrage verarbeiten wir anschließend in einer Schleife und schreiben die URL jedes einzelnen Placements in das vorbereitete Array:

  while (result.hasNext()) {
    var row = result.next();
    if ( placementUrls.indexOf(row['groupPlacementView']['targetUrl']) == -1 ) {
      placementUrls.push(row['groupPlacementView']['targetUrl']);
    }
  }

Die fertige Funktion sieht in unserem Beispiel wie folgt aus:

function queryPlacementUrls(){
  var placementUrls = [];
  var query = 
    "SELECT " +
    "  group_placement_view.target_url " +
    "FROM group_placement_view " +
    "WHERE " +
    "  campaign.status IN ('ENABLED', 'PAUSED') " +
    "  AND campaign.advertising_channel_type IN ('DISPLAY') " +
    "  AND group_placement_view.placement_type IN ('WEBSITE') " +
    "  AND group_placement_view.target_url NOT REGEXP_MATCH '.*\.(de|at|ch|com|net|org|info)' " +
    "  AND campaign.name REGEXP_MATCH '^GDN_.*$' " +
    ""
    ;
  var result = AdsApp.search(query, {apiVersion: 'v12'});
  while (result.hasNext()) {
    var row = result.next();
    if ( placementUrls.indexOf(row['groupPlacementView']['targetUrl']) == -1 ) {
      placementUrls.push(row['groupPlacementView']['targetUrl']);
    }
  }
  return placementUrls.sort();
}

Um die Funktion im Skript auszuführen, ergänzen wir den Aufruf innerhalb der Hauptfunktion main(). Den Rückgabewert der Funktion schreiben wir zur späteren Verwendung die Variable “placementUrls”:

function main(){
  var placementUrls = queryPlacementUrls();
}

Funktion getExcludedPlacements()

Bevor wir neue Placements in unserer Placement-Ausschlussliste ergänzen, möchten wir zuerst eine Liste der bereits ausgeschlossenen Placements erstellen, um diese nicht (noch einmal) zu verarbeiten.

Auch diese Funktion bereitet zu Beginn ein leeres Array vor, das anschließend befüllt und danach zurückgegeben wird. Mit der Variable “queryListName” übergeben wir später aus der Hauptfunktion main() heraus den Namen der Placement-Ausschlussliste, die das Skript verwenden soll.

function getExcludedPlacements(queryListName){
  var excludedPlacements = [];
  var sharedExcludedPlacementList = getExcludedPlacementList(queryListName);
  var sharedExcludedPlacementIterator = sharedExcludedPlacementList.excludedPlacements().get();
  while (sharedExcludedPlacementIterator.hasNext()) {
    var sharedExcludedPlacement = sharedExcludedPlacementIterator.next();
    excludedPlacements.push(sharedExcludedPlacement.getUrl());
  }
  return excludedPlacements.sort();
}

Die Funktionsweise ähnelt der vorausgegangen Funktion queryPlacementUrls(), allerdings ist die Datenquelle für die Stapelverarbeitung offenbar keine Abfrage, die mit dem Google Ads Query Builder gebaut wurde, sondern entstammt einer separaten Funktion getExcludedPlacementList(). 

Diese Hilfsfunktion haben wir uns gebaut, um sie später für die Ergänzung der Placement-Ausschlüsse wiederverwenden zu können. Schauen wir uns kurz die Funktionsweise dieser Hilfsfunktion an:

Funktion getExcludedPlacementList()

Die Funktion bedient sich der Methode excludedPlacementLists() der Google Ads API, mit deren Hilfe man Placement-Ausschlusslisten mit bestimmten Eigenschaften zur weiteren Verwendung innerhalb des Skripts abrufen kann.

In unserem Beispiel holen wir die erste gefundene Ausschlussliste ab und übergeben sie zurück an die aufrufende Funktion.

function getExcludedPlacementList(queryListName){
  var sharedExcludedPlacementList = AdsApp.excludedPlacementLists()
      .withCondition("Name = '" + queryListName + "'").get().next();
  return sharedExcludedPlacementList;
}

In der Hauptfunktion main() setzen wir nun den Namen für die zu verwendende Placement-Ausschlussliste und schreiben das Ergebnis der Funktion getExcludedplacements in die Variable “excludedPlacements”:

function main(){
  var placementUrls = queryPlacementUrls();
  var queryListName = 'Globale Placement-Ausschlüsse';
  var excludedPlacements = getExcludedPlacements(queryListName);
}

Funktion loadWhitelist()

Damit wir bestimmte Placements explizit erlauben können, auch wenn sie nicht auf eine der vordefinierten TLDs enden, haben wir uns eine Whitelist als Google Sheet angelegt, die wir manuell befüllen können. Diese Whitelist laden wir vor der weiteren Verarbeitung ebenfalls in ein Array.

Unschwer erkennbar sind die beiden Funktionsparameter, mit denen wir später die URL unseres Google Sheets und den Namen des darin enthaltenen Sheets mit der Whitelist an die Funktion übergeben.

function loadWhitelist(spreadsheetUrl,sheetName){
  const ss = SpreadsheetApp.openByUrl(spreadsheetUrl);
  const sheet = ss.getSheetByName(sheetName);
  const lastRow = sheet.getLastRow();
  const range = sheet.getRange(1, 1, lastRow);
  const values = range.getValues();
  var returnValues = [];
  for (i=0;i<values.length;i++){
    returnValues.push(values[i][0]);
  }
  return returnValues;
}

Den Ladevorgang ergänzen wir ebenfalls in der Hauptfunktion main() und definieren zuvor zwei globale Variablen mit den benötigten Werten:

const SPREADSHEET_URL = 'https://docs.google.com/spreadsheets/d/----------/';
const SHEET_NAME = 'placements';

function main(){
  var placementUrls = queryPlacementUrls();
  var queryListName = 'Globale Placement-Ausschlüsse';
  var excludedPlacements = getExcludedPlacements(queryListName);
  var whitelist = loadWhitelist(SPREADSHEET_URL,SHEET_NAME);
}

Funktion getToBeExcludedPlacements()

Im nächsten Schritt ermitteln wir die auszuschließenden Placements. Diese Funktion verarbeitet alle drei zuvor vorbereiteten Listen bzw. Arrays:

• placementUrls – alle vermeintlich unerwünschten Placements
• excludedPlacements – alle bereits ausgeschlossenen Placements
• whitelist – alle explizit gewünschten Placements

Die im Stapel “placementUrls” enthaltenen Placements werden zunächst einzeln gegen die Whitelist geprüft. Ist das jeweilige Placement darin enthalten, wird es ignoriert. Für unsere Bestätigungsmail zählen wir außerdem die in der Whitelist gefundenen Placements mit.

Wenn das Placement nicht auf der Whitelist steht, wird als nächstes geprüft, ob es bereits in der Placement-Ausschlussliste enthalten ist. Falls nicht, wird es im Rückgabe-Array “toBeExcludedPlacements” ergänzt.

Sobald alle Placements gegen die Whitelist geprüft wurden, wird das Rückgabe-Array nebst Whitelist-Zähler an die aufrufende Funktion zurückgegeben.

function getToBeExcludedPlacements(placementUrls,excludedPlacements,whitelist){
  var toBeExcludedPlacements = [];
  var numWhitelisted = 0;
  for (var i=0;i<placementUrls.length;i++){
      if (whitelist.indexOf(placementUrls[i]) != -1){
        numWhitelisted++;
      } else if (excludedPlacements.indexOf(placementUrls[i]) == -1){
          toBeExcludedPlacements.push(placementUrls[i]);
      }
  }
  return [toBeExcludedPlacements.sort(),numWhitelisted];
}

Nach Ergänzung der neuen Funktion in der Hauptfunktion main() sieht der Kopfbereich des Skripts wie folgt aus:

const SPREADSHEET_URL = 'https://docs.google.com/spreadsheets/d/----------/';
const SHEET_NAME = 'placements';

function main(){
  var placementUrls = queryPlacementUrls();
  var queryListName = 'Globale Placement-Ausschlüsse';
  var excludedPlacements = getExcludedPlacements(queryListName);
  var whitelist = loadWhitelist(SPREADSHEET_URL,SHEET_NAME);
  var toBeExcludedPlacements = getToBeExcludedPlacements(placementUrls,excludedPlacements,whitelist);
}

Funktion addExcludedPlacement()

Nachdem wir nun alle zu ergänzenden Placement-Ausschlüsse zusammen haben, brauchen wir sie nur noch zu der bestehenden Placement-Ausschlussliste hinzufügen. Die Funktion dazu ist wieder relativ einfach gehalten.

Sie empfängt neben dem Namen der zu verwendenden Placement-Ausschlussliste auch das Array mit den auszuschließenden Placements, ruft die Ausschlussliste auf und hängt die Placements an.

function addExcludedPlacement(queryListName,toBeExcludedPlacements){
  var sharedExcludedPlacementList = getExcludedPlacementList(queryListName);
  sharedExcludedPlacementList.addExcludedPlacements(toBeExcludedPlacements);
}

Eigentlich wäre unser Skript damit schon fertig. Der Kopfbereich sieht jetzt wie folgt aus:

const SPREADSHEET_URL = 'https://docs.google.com/spreadsheets/d/----------/';
const SHEET_NAME = 'placements';

function main(){
  var placementUrls = queryPlacementUrls();
  var queryListName = 'Globale Placement-Ausschlüsse';
  var excludedPlacements = getExcludedPlacements(queryListName);
  var whitelist = loadWhitelist(SPREADSHEET_URL,SHEET_NAME);
  var toBeExcludedPlacements = getToBeExcludedPlacements(placementUrls,excludedPlacements,whitelist);
  addExcludedPlacement(queryListName,toBeExcludedPlacements[0]);
}

Funktion sendConfirmationEmail()

Damit wir aber auch mitbekommen, welche Placements neu ausgeschlossen wurden, lassen wir uns vom Skript eine Mail mit einer Liste der neu ausgeschlossenen URLs schicken.

Diese Funktion empfängt als Parameter ebenfalls den Namen der Ausschlussliste und das Rückgabe-Array mit der Liste der auszuschließenden Placements und dem Whitelist-Zähler.

Damit bereitet es den Output für die zu erstellende E-Mail vor. Zuerst wird die String-Variable “outputPlacements” zeilenweise mit den URLs der ausgeschlossenen Placements befüllt. Es folgt die Definition der Empfängeradresse(n) und des Betreffs, sowie des E-Mail-Inhalts. An dessen Ende wird die URL-Liste angehängt.

function sendConfirmationEmail(queryListName,toBeExcludedPlacements){
  var outputPlacements = "";
  for (i=0;i<toBeExcludedPlacements[0].length;i++){
      outputPlacements += toBeExcludedPlacements[0][i] + "\n";
  }
  var eMailAddress = "rs@adtraffic.de";
  var eMailSubject = "Placement Excluder // Mein Account-Name";
  var eMailContent = toBeExcludedPlacements[0].length.toLocaleString("de") + " Placement(s) in Placement-Ausschlussliste " + queryListName + " ergänzt." + "\n" +
      toBeExcludedPlacements[1] + " Placement(s) übersprungen (whitelisted)." + "\n\n" + outputPlacements;
  console.log(eMailContent);
  sendSimpleTextEmail(eMailAddress,eMailSubject,eMailContent)
}

Funktion sendSimpleTextEmail()

Den eigentlichen Versand der fertigen Bestätigungsmail übernimmt diese Hilfsfunktion aus der Google Ads Scripts Bibliothek.

function sendSimpleTextEmail(eMailAddress,eMailSubject,eMailContent) {
  MailApp.sendEmail(eMailAddress,eMailSubject,eMailContent);
  Logger.log("Mail sent.");
}

Und damit ist unser Skript bereit für den Einsatz. Der Kopfbereich sieht jetzt so aus:

const SPREADSHEET_URL = 'https://docs.google.com/spreadsheets/d/----------/';
const SHEET_NAME = 'placements';

function main(){
  var placementUrls = queryPlacementUrls();
  var queryListName = 'Globale Placement-Ausschlüsse';
  var excludedPlacements = getExcludedPlacements(queryListName);
  var whitelist = loadWhitelist(SPREADSHEET_URL,SHEET_NAME);
  var toBeExcludedPlacements = getToBeExcludedPlacements(placementUrls,excludedPlacements,whitelist);
  addExcludedPlacement(queryListName,toBeExcludedPlacements[0]);
  sendConfirmationEmail(queryListName,toBeExcludedPlacements);
}

Author/License Header hinzugefügt

Der Form halber haben wir in unserer Version noch einen Info-Header hinzugefügt.

//            _ _              __  __ _      
//   __ _  __| | |_ _ __ __ _ / _|/ _(_) ___ 
//  / _` |/ _` | __| '__/ _` | |_| |_| |/ __|
// | (_| | (_| | |_| | | (_| |  _|  _| | (__ 
//  \__,_|\__,_|\__|_|  \__,_|_| |_| |_|\___|
//                                           
// Placement Excluder 23.1 (c) 2023 by R. Stinauer & R. Frank
//
// E: info@adtraffic.de | W: www.adtraffic.de

Weitere Berechtigungen

Das Script benötigt für den Zugriff auf das Google Sheet mit der Whitelist und den Versand der Bestätigungsmail noch weitere Berechtigungen, die es spätestens bei der ersten Ausführung abfragt. Die entsprechende Meldung taucht am unteren Rand auf:

Folgende zusätzliche Berechtigungen werden benötigt:

Zeitplan

Um das fertige Skript automatisch laufen zu lassen, stellen wir auf der Übersichtsseite die Zeitplanung in der Spalte “Häufigkeit” ein.

In unserem Beispiel lassen wir das Skript jeden Montag zwischen 7 und 8 Uhr laufen.

Zusammenfassung

Automatisierungsmöglichkeiten für Google Ads Kampagnen schlummern hinter den meisten operativen Handgriffen. Wir hoffen, Du hast anhand unseres konkreten Beispiels eine genaue(re) Vorstellung davon bekommen, wie Dich Google Ads Scripts bei Deinen täglichen Aufgaben unterstützen können. Unser Artikel hat Dich hoffentlich auch dazu ermuntert, Dich näher mit Google Ads Scripts zu beschäftigen. Vielleicht hast Du auch schon eine konkrete Idee zum Bau Deiner skript-basierten Lösung für ein individuelles Problem. Wir wünschen Dir viele Freude beim Experimentieren und viel Erfolg mit Deinem ersten Google Ads Script!

ChatGPT

Vielleicht hast Du Dich gerade gefragt: “Kann ich mir das nicht einfach von ChatGPT schreiben lassen?”

Auf die Frage “Could you create Google Ads scripts using the latest Google Ads API version?” antwortete uns das KI-Netzwerk hilfsbereit, aber zurückhaltend:

“As an AI language model, I can provide you with an overview of how Google Ads scripts could be written using the latest Google Ads API version. However, writing complete and functional scripts is beyond my capabilities as it requires knowledge of specific programming languages and expertise in Google Ads scripting.”

Tatsächlich wendet ChatGPT zur Erstellung von Code-Snippets für Google Ads Scripts teils veraltete API-Syntax an und ergänzt bei Bedarf auch gerne mal erfundene Methoden.

Lass Dir also gerne von ChatGPT helfen, aber probier es doch vorher einmal ohne KI…

Downloads

Möchtest Du diesen Artikel lieber als PDF herunterladen? Kein Problem. Die Datei findest Du unter folgendem Link: Dein-Erstes-Google-Ads-Script-230324.pdf

Du möchtest den Script-Code in einem Stück herunterladen? Auch kein Problem. Die JS-Datei findest Du in folgendem ZIP-Archiv: google-ads-script-placement-excluder.js.zip

Happy Scripting!

The post Dein Erstes Google Ads Script appeared first on adtraffic.

“Das Language Targeting erlaubt es, User zu targeten, die der jeweiligen Sprache mit sehr hoher Wahrscheinlichkeit mächtig sind. Hierzu verwenden wir unter anderem die gewünschte Sprache des Users bei Youtube, den Standort und die Browsereinstellung.”

Das führt dazu, dass Videoanzeigen häufig in fremdsprachigen Kanälen ausgespielt werden. Möchte man diese YouTube Kanäle händisch ausschließen, benötigt man viel Geduld. Schneller und vor allem automatisiert geht es mit einem Google Ads Script.

Unser nachfolgendes Beispiel Script ermittelt YouTube Kanäle in nicht gewünschten Ländern, auf denen die Videokampagne(n) ausgespielt wurde(n) und schließt sie automatisch in der jeweiligen Kampagne aus.

Was macht dieses Script genau?

• Videokampagnen auswählen
  Das Script wählt zunächst alle aktiven Videokampagnen aus dem jeweiligen Google Ads Konto aus.
• Bestehende Ausschlüsse ermitteln
  Für jede Kampagne werden zunächst die bereits ausgeschlossenen YouTube Kanäle zum späteren Abgleich geladen.
• Bestätigte YouTube Kanäle importieren
  Aus einer externen Liste lädt das Script alle bereits bestätigten YouTube Kanäle.
• Neue YouTube Placements abfragen
  Anschließend fragt das Script alle aktiven YouTube Placements der jeweiligen Kampagne ab, die bisher nicht bestätigt oder ausgeschlossen wurden.
• YouTube Kanalinfos abrufen
  Zu den ermittelten YouTube Placements ruft das Script nun die jeweiligen Kanalinfos ab.
• Neue bestätigte YouTube Kanäle exportieren
  Alle YouTube Kanäle in gewünschten Ländern werden in die Liste mit bestätigten Kanälen exportiert.
• YouTube Kanäle in unerwünschten Ländern ausschließen
  Alle anderen Kanäle schließt das Script auf Kampagnenebene aus.
• Bestätigungs-E-Mail
  Abschließend versendet das Script eine Übersicht der ausgeschlossenen YouTube Kanäle per E-Mail.

Das Setup

Bei diesem Beispiel handelt es sich um ein Single Account Script. Eine MCC Version wird folgen, kann aber auch relativ einfach adaptiert werden. Das Script wird direkt in Google Ads unter Tools & Einstellungen > Bulk-Aktionen > Scripts angelegt.

Die erweiterte API “YouTube” wird benötigt. Für die API-Abrufe fallen Credits an. Mit einem regulären Google Konto hat man pro Tag 10.000 freie Credits. Ein höheres Kontingent muss bei Google beantragt werden.

Das fertige Script muss für den Zugriff auf Drive, Mail und YouTube autorisiert werden.

Die Code Bausteine

Nachfolgend erkläre ich zunächst die einzelnen Bausteine. Der komplette Code kann am Ende des Dokuments eingesehen werden.

Einstellungen

var SPREADSHEET_URL = "INSERT_YOUR_SPREADSHEET_URL";
var SHEET_NAME = "INSERT_YOUR_SPREAD_NAME";
var EMAIL_ADRESSES = "INSERT_YOUR_E-MAIL_ADRESSES"; // comma separated
var allowedCountries = /^DE$/; // Provide RegEx, e.g. /^DE$/ or /^DE|AT|CH$/
var impressionsTimeRange = "LAST_7_DAYS";
var impressionsThreshold = 10;

Das hinterlegte Google Sheet benötigt nur eine Spalte mit einem Beispielwert in der ersten Zeile.

Der Sheet Name dient dazu, falls mehrere solcher Whitelists in einem Google Sheet gespeichert sind.

Es kann eine oder auch mehrere E-Mail-Adressen angegeben werden. Mehrere Adressen bitte mit Komma trennen.

Der Wert für “allowedCountries” muss ein regulärer Ausdruck mit zweistelligen Ländercodes nach ISO 3166-1 Alpha-2 sein.

Die Optionen für “impressionsTimeRange” können einem Wert aus der Liste “Predefined date range” der Google Ads API enthalten.

Für “impressionsThreshold” kann man einen Schwellwert eintragen, um nur die reichweitenstärksten YouTube Placements zu verarbeiten und so API Credits zu sparen.

Funktion main() – Teil 1

function main() {
  // Prepare an array for logging purposes
  var allExclusions = [];
  // Fetch all active video campaigns and start iterating
  var videoCampaignIterator = AdsApp.videoCampaigns().withCondition("Status = 'ENABLED'").get();
  while (videoCampaignIterator.hasNext()) {
    var alreadyExcludedYouTubeChannels = [];
    var videoCampaign = videoCampaignIterator.next();
    // Fetch all already excluded YouTube Channels from the processed campaign and store them in an array
    var exludedYoutubeChannelIterator = videoCampaign.videoTargeting().excludedYouTubeChannels().get();
    while (exludedYoutubeChannelIterator.hasNext()) {
      var excludedYouTubeChannel = exludedYoutubeChannelIterator.next();
      alreadyExcludedYouTubeChannels.push(excludedYouTubeChannel.getChannelId());
    }
    // Build a batch with to be excluded YouTube channels
    const toBeExcludedYouTubeChannels = checkYouTubeChannels(videoCampaign.getId(),alreadyExcludedYouTubeChannels);

Wie aus den Kommentaren ersichtlich, werden hier zunächst die aktiven Videokampagnen geladen und die zugehörigen, bereits ausgeschlossenen YouTube Placements abgerufen.

Für jede Kampagne wird dann die Funktion “checkYouTubeChannels” unter Verwendung der jeweiligen Kampagnen ID und dem Array mit bereits ausgeschlossenen Placements aufgerufen.

Funktion checkYouTubeChannels() – Teil 1

function checkYouTubeChannels(campaignId,alreadyExcludedYouTubeChannels){
  // Prepare an array for the return values  
  var toBeExcludedYouTubeChannels = [];
  // Load currently known allowed YouTube Channels from Google Sheet
  var knownAllowedYouTubeChannels = getAllowedYouTubeChannels();

Diese Funktion bereitet zunächst ein leeres Array für die Zwischenspeicherung der Rückgabewerte vor und ruft die Funktion “getAllowedYouTubeChannels” auf, um die bereits bestätigten YouTube Kanäle aus dem externen Google Sheet zu importieren.

Funktion getAllowedYouTubeChannels()

function getAllowedYouTubeChannels(){
  var sheet = SpreadsheetApp.openByUrl(SPREADSHEET_URL).getSheetByName(SHEET_NAME);
  var lastRow = sheet.getLastRow();
  var range = sheet.getRange(1, 1, lastRow);
  var returnValues = [];
  var values = range.getValues();
  for (var row in values) {
    for (var col in values[row]) {
      returnValues.push(values[row][col]);
    }
  }
  return returnValues;
}

An sich eine sehr einfache Funktion zum Abruf der Daten aus dem Google Sheet. Wichtig ist hierbei, dass die zweidimensionalen “values” am Ende als eindimensionale “returnValues” übergeben werden.

Funktion checkYouTubeChannels() – Teil 2

// Prepare an array for newly identified allowed YouTube Channels to be added to the Google Sheet
  var newAllowedYouTubeChannels = [];
  // Query all YouTube placements of the processed campaign with at least ${impressionsThreshold} impressions within the ${impressionsTimeRange}
  var query = 
    "SELECT detail_placement_view.display_name, detail_placement_view.group_placement_target_url FROM detail_placement_view " +
    "WHERE " +
    "  campaign.id = " + campaignId +
    "  AND segments.date DURING " + impressionsTimeRange +
    "  AND metrics.impressions > " + impressionsThreshold + 
    "  AND detail_placement_view.placement_type IN ('YOUTUBE_VIDEO','YOUTUBE_CHANNEL') " +
    "  AND detail_placement_view.group_placement_target_url IS NOT NULL " +
    "  AND detail_placement_view.group_placement_target_url NOT REGEXP_MATCH '" + alreadyExcludedYouTubeChannels.join("|") + "'" +
    "  AND detail_placement_view.group_placement_target_url NOT REGEXP_MATCH '" + knownAllowedYouTubeChannels.join("|") + "'" +
    ""
    ;
  var result = AdsApp.search(query);
  console.log(result.totalNumEntities() + " YouTube Placements found.");
  while (result.hasNext()) {
    var row = result.next();
    const channelId = row['detailPlacementView']['groupPlacementTargetUrl'].match(/^.*\/([^\/]*)$/)[1];
    const channelName = row['detailPlacementView']['displayName'];
    const channelInfo = getChannelInfo(channelId); // [ Country, Default Language ]

Zurück in der Funktion “checkYouTubeChannels” ruft das Script nun alle YouTube Placements der jeweiligen Kampagne ab, die den Kriterien unter “Einstellungen” entsprechen und bisher weder bestätigt noch ausgeschlossen wurden. Bei der Iteration der daraus resultierenden Ergebnisse werden dann mithilfe der Funktion “getChannelInfo” die Daten von dem YouTube Data API abgefragt.

Funktion getChannelInfo()

function getChannelInfo(channelId){
  try {
    const results = YouTube.Channels.list('snippet,localizations', {
      id: channelId,
      maxResults: 1
    });
    if (results === null) {
      console.log(`ID ${channelId}: Unable to search videos`);
      return;
    }
    return [ results.items[0].snippet.country, results.items[0].snippet.defaultLanguage ];
  } catch (err) {
    // TODO (developer) - Handle exceptions from Youtube API
    console.log(`ID ${channelId}: Failed with an error: %s`, err.message);
  }  
}

Diese ebenfalls sehr einfach gehaltene Funktion ruft lediglich das eingestellte Land und die eingestellte Standardsprache für den jeweiligen YouTube Kanal ab und gibt die Werte als Mini-Array zurück.

Funktion checkYouTubeChannels() – Teil 3

    if ( channelInfo && channelInfo[0]){
      if (channelInfo[0].match(allowedCountries) && knownAllowedYouTubeChannels.indexOf(channelId) == -1 && newAllowedYouTubeChannels.indexOf(channelId) == -1){
        // Store channel id of newly identified German YouTube Channel in array to be added to Google Sheet
        newAllowedYouTubeChannels.push(channelId);
      }
      else if (!channelInfo[0].match(allowedCountries)){
        if ( alreadyExcludedYouTubeChannels.indexOf(channelId) == -1){
          toBeExcludedYouTubeChannels.push(
            {
              id: channelId,
              name: channelName,
              country: channelInfo[0],
              language: channelInfo[1]
            }
          );
        }
      }
    }
  }

Basierend auf den zurückgegebenen Kanalinfos wird die Kanal ID des jeweils verarbeiteten Placements entweder für den Export in die Liste bestätigter Kanäle zwischengespeichert oder in den Stapel zum späteren Ausschluss geschrieben.

Funktion checkYouTubeChannels() – Teil 4

if (newAllowedYouTubeChannels.length > 0){
    saveAllowedYouTubeChannels(newAllowedYouTubeChannels);
    newAllowedYouTubeChannels.length.toLocaleString("de") + " new allowed Channel(s) found." + "\n\n";
  }
  return toBeExcludedYouTubeChannels.sort();
}

Der Export in die Liste bestätigter YouTube Kanäle erfolgt unmittelbar. Der Stapel mit den auszuschließenden YouTube Kanälen pro Kampagne wird als Array an die Funktion “main” zurückgegeben.

Funktion saveAllowedYouTubeChannels()

function saveAllowedYouTubeChannels(newAllowedYouTubeChannels){
  var sheet = SpreadsheetApp.openByUrl(SPREADSHEET_URL).getSheetByName(SHEET_NAME);
  var lastRow = sheet.getLastRow();
  var range = sheet.getRange(lastRow+1,1,newAllowedYouTubeChannels.length);
  var outputValues = [];
  while(newAllowedYouTubeChannels.length) outputValues.push(newAllowedYouTubeChannels.splice(0,1));
  range.setValues(outputValues);
  sheet.sort(1);
}

Auch diese Funktion ist sehr einfach gehalten. Sehr hilfreich ist die knappe while/push/slice Schleife, um die eindimensionale Liste mit Kanal IDs in das erforderliche zweidimensionale Ausgabeformat für Google Sheets zu bekommen.

Funktion main() – Teil 2

    // Exclude all YouTube channels in batch from campaign
    for (i=0;i<toBeExcludedYouTubeChannels.length;i++){
      videoCampaign.videoTargeting().newYouTubeChannelBuilder().withChannelId(toBeExcludedYouTubeChannels[i].id).exclude();
    }
    // Add logging information to log array
    allExclusions.push({ campaign: videoCampaign.getName(), excludedYouTubeChannels: toBeExcludedYouTubeChannels })
  }
  // Prepare and send a notification email with logging information
  sendConfirmationEmail(allExclusions);
}

Zurück in der “main” Funktion arbeitet das Script den Stapel mit auszuschließenden YouTube Kanälen ab und ergänzt diese in der jeweiligen Kampagne. Anschließend ruft es die Funktion “sendConfirmationEmail” mit den zuvor aufbereiteten Logging-Daten auf, um die Bestätigungs-E-Mail zu versenden.

Funktion sendConfirmationEmail()

function sendConfirmationEmail(allExclusions){
  var output = "";
  for (i=0;i<allExclusions.length;i++){
    output += allExclusions[i].excludedYouTubeChannels.length.toLocaleString("de") + " Channel(s) excluded from Campaign " + allExclusions[i].campaign + "\n\n";
    var outputChannels = "";
    for (j=0;j<allExclusions[i].excludedYouTubeChannels.length;j++){
        outputChannels += allExclusions[i].excludedYouTubeChannels[j].name + " (" + allExclusions[i].excludedYouTubeChannels[j].country + "|" + allExclusions[i].excludedYouTubeChannels[j].language + ")\n";
        outputChannels += "https://youtube.com/channel/" + allExclusions[i].excludedYouTubeChannels[j].id + "\n\n";
    }
    output += outputChannels;
  }  
  var eMailAddress = EMAIL_ADRESSES;
  var eMailSubject = "YouTube Channel Excluder";
  var eMailContent = output;
  console.log(output);
  sendSimpleTextEmail(eMailAddress,eMailSubject,eMailContent)
}

Diese Funktion bereitet nun noch den Inhalt für die Bestätigungs-E-Mail auf und verschickt sie anschließend mit der einfachen Hilfsfunktion “sendSimpleTextEmail” an die hinterlegten E-Mail-Adressen.

Hilfsfunktion sendSimpleTextEmail()

function sendSimpleTextEmail(eMailAddress,eMailSubject,eMailContent) {
  MailApp.sendEmail(eMailAddress,eMailSubject,eMailContent);
  Logger.log("Mail sent.");
}

Kein Kommentar. 🙂

Der vollständige Code

Happy Copy & Pasting! Und viel Erfolg bei der Optimierung Eurer Google Ads Video Kampagnen!

var SPREADSHEET_URL = "INSERT_YOUR_SPREADSHEET_URL";
var SHEET_NAME = "INSERT_YOUR_SPREAD_NAME";
var EMAIL_ADRESSES = "INSERT_YOUR_E-MAIL_ADRESSES"; // comma separated
var allowedCountries = /^DE$/; // Provide RegEx, e.g. /^DE$/ or /^DE|AT|CH$/
var impressionsTimeRange = "LAST_7_DAYS";
var impressionsThreshold = 10;

function main() {
  // Prepare an array for logging purposes
  var allExclusions = [];
  // Fetch all active video campaigns and start iterating
  var videoCampaignIterator = AdsApp.videoCampaigns().withCondition("Status = 'ENABLED'").get();
  while (videoCampaignIterator.hasNext()) {
    var alreadyExcludedYouTubeChannels = [];
    var videoCampaign = videoCampaignIterator.next();
    // Fetch all already excluded YouTube Channels from the processed campaign and store them in an array
    var exludedYoutubeChannelIterator = videoCampaign.videoTargeting().excludedYouTubeChannels().get();
    while (exludedYoutubeChannelIterator.hasNext()) {
      var excludedYouTubeChannel = exludedYoutubeChannelIterator.next();
      alreadyExcludedYouTubeChannels.push(excludedYouTubeChannel.getChannelId());
    }
    // Build a batch with to be excluded YouTube channels
    const toBeExcludedYouTubeChannels = checkYouTubeChannels(videoCampaign.getId(),alreadyExcludedYouTubeChannels);
    // Exclude all YouTube channels in batch from campaign
    for (i=0;i<toBeExcludedYouTubeChannels.length;i++){
      videoCampaign.videoTargeting().newYouTubeChannelBuilder().withChannelId(toBeExcludedYouTubeChannels[i].id).exclude();
    }
    // Add logging information to log array
    allExclusions.push({ campaign: videoCampaign.getName(), excludedYouTubeChannels: toBeExcludedYouTubeChannels })
  }
  // Prepare and send a notification email with logging information
  sendConfirmationEmail(allExclusions);
}

function checkYouTubeChannels(campaignId,alreadyExcludedYouTubeChannels){
  // Prepare an array for the return values  
  var toBeExcludedYouTubeChannels = [];
  // Load currently known allowed YouTube Channels from Google Sheet
  var knownAllowedYouTubeChannels = getAllowedYouTubeChannels();
  // Prepare an array for newly identified allowed YouTube Channels to be added to the Google Sheet
  var newAllowedYouTubeChannels = [];
  // Query all YouTube placements of the processed campaign with at least ${impressionsThreshold} impressions within the ${impressionsTimeRange}
  var query = 
    "SELECT detail_placement_view.display_name, detail_placement_view.group_placement_target_url FROM detail_placement_view " +
    "WHERE " +
    "  campaign.id = " + campaignId +
    "  AND segments.date DURING " + impressionsTimeRange +
    "  AND metrics.impressions > " + impressionsThreshold + 
    "  AND detail_placement_view.placement_type IN ('YOUTUBE_VIDEO','YOUTUBE_CHANNEL') " +
    "  AND detail_placement_view.group_placement_target_url IS NOT NULL " +
    "  AND detail_placement_view.group_placement_target_url NOT REGEXP_MATCH '" + alreadyExcludedYouTubeChannels.join("|") + "'" +
    "  AND detail_placement_view.group_placement_target_url NOT REGEXP_MATCH '" + knownAllowedYouTubeChannels.join("|") + "'" +
    ""
    ;
  var result = AdsApp.search(query);
  console.log(result.totalNumEntities() + " YouTube Placements found.");
  while (result.hasNext()) {
    var row = result.next();
    const channelId = row['detailPlacementView']['groupPlacementTargetUrl'].match(/^.*\/([^\/]*)$/)[1];
    const channelName = row['detailPlacementView']['displayName'];
    const channelInfo = getChannelInfo(channelId); // [ Country, Default Language ]
    if ( channelInfo && channelInfo[0]){
      if (channelInfo[0].match(allowedCountries) && knownAllowedYouTubeChannels.indexOf(channelId) == -1 && newAllowedYouTubeChannels.indexOf(channelId) == -1){
        // Store channel id of newly identified German YouTube Channel in array to be added to Google Sheet
        newAllowedYouTubeChannels.push(channelId);
      }
      else if (!channelInfo[0].match(allowedCountries)){
        if ( alreadyExcludedYouTubeChannels.indexOf(channelId) == -1){
          toBeExcludedYouTubeChannels.push(
            {
              id: channelId,
              name: channelName,
              country: channelInfo[0],
              language: channelInfo[1]
            }
          );
        }
      }
    }
  }
  if (newAllowedYouTubeChannels.length > 0){
    saveAllowedYouTubeChannels(newAllowedYouTubeChannels);
    newAllowedYouTubeChannels.length.toLocaleString("de") + " new allowed Channel(s) found." + "\n\n";
  }
  return toBeExcludedYouTubeChannels.sort();
}

function getChannelInfo(channelId){
  try {
    const results = YouTube.Channels.list('snippet,localizations', {
      id: channelId,
      maxResults: 1
    });
    if (results === null) {
      console.log(`ID ${channelId}: Unable to search videos`);
      return;
    }
    return [ results.items[0].snippet.country, results.items[0].snippet.defaultLanguage ];
  } catch (err) {
    // TODO (developer) - Handle exceptions from Youtube API
    console.log(`ID ${channelId}: Failed with an error: %s`, err.message);
  }  
}

function getAllowedYouTubeChannels(){
  var sheet = SpreadsheetApp.openByUrl(SPREADSHEET_URL).getSheetByName(SHEET_NAME);
  var lastRow = sheet.getLastRow();
  var range = sheet.getRange(1, 1, lastRow);
  var returnValues = [];
  var values = range.getValues();
  for (var row in values) {
    for (var col in values[row]) {
      returnValues.push(values[row][col]);
    }
  }
  return returnValues;
}

function saveAllowedYouTubeChannels(newAllowedYouTubeChannels){
  var sheet = SpreadsheetApp.openByUrl(SPREADSHEET_URL).getSheetByName(SHEET_NAME);
  var lastRow = sheet.getLastRow();
  var range = sheet.getRange(lastRow+1,1,newAllowedYouTubeChannels.length);
  var outputValues = [];
  while(newAllowedYouTubeChannels.length) outputValues.push(newAllowedYouTubeChannels.splice(0,1));
  range.setValues(outputValues);
  sheet.sort(1);
}

function sendConfirmationEmail(allExclusions){
  var output = "";
  for (i=0;i<allExclusions.length;i++){
    output += allExclusions[i].excludedYouTubeChannels.length.toLocaleString("de") + " Channel(s) excluded from Campaign " + allExclusions[i].campaign + "\n\n";
    var outputChannels = "";
    for (j=0;j<allExclusions[i].excludedYouTubeChannels.length;j++){
        outputChannels += allExclusions[i].excludedYouTubeChannels[j].name + " (" + allExclusions[i].excludedYouTubeChannels[j].country + "|" + allExclusions[i].excludedYouTubeChannels[j].language + ")\n";
        outputChannels += "https://youtube.com/channel/" + allExclusions[i].excludedYouTubeChannels[j].id + "\n\n";
    }
    output += outputChannels;
  }  
  var eMailAddress = EMAIL_ADRESSES;
  var eMailSubject = "YouTube Channel Excluder";
  var eMailContent = output;
  console.log(output);
  sendSimpleTextEmail(eMailAddress,eMailSubject,eMailContent)
}

// HELPERS

function sendSimpleTextEmail(eMailAddress,eMailSubject,eMailContent) {
  MailApp.sendEmail(eMailAddress,eMailSubject,eMailContent);
  Logger.log("Mail sent.");
}

The post Google Ads Script: YouTube Channel Excluder appeared first on adtraffic.

Mit zunehmender Komplexität geht Google Looker Studio in die Knie und bedankt sich mit sehr langen Ladezeiten. Ein Multichannel Reporting umfasst bei uns schnell mal 110 Diagramme und 48 Filter auf 13 Seiten.

Im nachfolgenden Artikel wird erklärt, wie man durch die Aufbereitung der Daten in BigQuery die Geschwindigkeit und damit die Bedienungsfreundlichkeit von Looker Studio Reports erheblich steigern kann.

— innerhalb weniger Sekunden —

Denn die lange Ladezeit liegt an der Aggregation und Verarbeitung der Daten von Google Looker Studio. Wenn die Daten vorher in BigQuery aufbereitet werden, laden auch Looker Studio Reports mit mehreren hunderttausend Produkten und Millionen Datenpunkten innerhalb weniger Sekunden.

Wie sieht eine optimierte Datenquelle für Looker Studio aus?

Ziel ist es, eine einzige, möglichst flache Datenquelle zu generieren. Aus dieser kann Looker Studio die Daten für die Diagramme und Filter ziehen, ohne diese vorher mit weiteren Datenquellen verknüpfen zu müssen oder komplizierte Berechnungen in benutzerdefinierten Feldern innerhalb der Datenquelle durchführen zu müssen. Stellen Sie deshalb zunächst zusammen, welche Messwerte dargestellt werden sollen und nach welchen Dimensionen Sie diese filtern oder segmentieren möchten.

Für unser Beispiel benötigen wir folgende Datenfelder:

• Messwerte: Besuche, Bestellungen, Neukunden, Umsatz, Kosten
• Berechnete Felder: Konversionsrate, Kosten/Umsatz-Relation, Neukundenquote
• Dimensionen: Datum, Kanal, Unterkanal

Um später bei der Wahl der Auswertungszeiträume und etwaiger Vergleichszeiträume, sowie bei der segmentierten Darstellung – zum Beispiel nach Wochen – möglichst flexibel zu sein, benötigen Sie die Daten auf Tagesbasis.

So könnte die Kopfzeile der benötigten Datenquelle aussehen:

Woher kommen die Daten für das Reporting?

Besuche, Bestellungen, Neukunden und Umsatz je Datum, Kanal und Unterkanal erhalten Sie idealerweise aus Ihrem Webanalysetool. Mit Tools wie Supermetrics lassen sich die Daten automatisiert abrufen und zum Beispiel in einem Google Sheet oder direkt in BigQuery speichern.

Die Kostendaten stammen üblicherweise direkt von den Plattformen, in unserem Beispiel aggregieren wir diese von Google, Bing, Meta und drei Preisvergleichsportalen. Auch die Daten der ersten drei Anbieter können Sie über Tools sehr einfach in der benötigten Form abrufen. Bei den Preisvergleichern müssen Sie aber vermutlich improvisieren:

— Automatisieren mit Scripts —

Nehmen wir an, der erste Preisvergleicher schickt die Daten als Anlage per E-Mail, der zweite lädt sie via FTP auf Ihren Server hoch und der dritte bietet einen Datenabruf mittels API an. Spätestens an dieser Stelle würden einige vermutlich zur manuellen Übertragung wechseln und die relevanten Daten aus den Reports der Preisvergleicher in ein Google Sheet importieren. Wir automatisieren das in unserem Beispiel mit einem kleinen Bash Script und zwei kleinen Google Scripts.

Wie kommen die Daten in Form?

Die zusammengestellten Kostendaten müssen später anhand von Datum, Kanal und Unterkanal der jeweiligen Datenzeile aus dem Webanalysetool zugeordnet werden. Dabei hilft eine schematische Benennung aller Kampagnen und/oder ein durchgängiges Tracking mit URL-Parametern.

In unserem Beispiel verwenden wir vom Kunden definierte Kampagnen-Codes, die in allen Kampagnen als URL-Parameter angehängt werden. Mithilfe der Kampagnen-Codes und einer Matching-Tabelle können wir sowohl Kostendaten als auch die Daten aus der Webanalyse eindeutig einem Unterkanal zuordnen.

Als Zwischenstufe können Sie sich folgende Rohdatenquellen vorstellen:

Daten aus der Webanalyse:

Kostendaten je Plattform:

Matching-Tabelle für Kampagnen-Codes:

Liegen alle Daten in dieser Form vor, ist es mit BigQuery relativ einfach, diese zu einer flachen Datenquelle für Looker Studio zu kombinieren. Aber eins nach dem anderen…

Vorbereitung (optional)

Für die weiteren Schritte ist es hilfreich, wenn Sie sich bereits mit Ihrem Google Konto in der Google Cloud angemeldet und dort in BigQuery ein Projekt mit einem Dataset eingerichtet haben. 

Einen Einstieg in die Funktionsweise von Abfragen in BigQuery erhalten Sie hier: Overview of BigQuery analytics | Google Cloud. Wenn Sie noch eine Stufe früher einsteigen möchten, beginnen Sie am Besten hier: Enable the BigQuery sandbox | Google Cloud.

Abrufen und Importieren der Daten in BigQuery

Wir nutzen in unserem Beispiel das Tool Supermetrics for Google Sheets und speichern die abgerufenen Daten in einem Google Sheet, das wir anschließend als externe Tabelle in BigQuery importieren. Dazu erstellen wir in unserem Dataset eine neue Tabelle aus “Drive” im Dateiformat “Google-Tabelle” unter Angabe der URL des Google Sheets.

Als Ziel des Imports definieren wir in unserem bestehenden Dataset eine neue Tabelle, der wir einen sprechenden Namen geben, zum Beispiel “import_webanalyse”:

Das Schema für die Tabelle, also die Feldnamen und jeweiligen Datentypen, definieren wir manuell mit sprechenden Bezeichnungen für die weitere Verwendung in SQL-Abfragen:

Sofern im Google Sheet eine Kopfzeile vorhanden ist, überspringen wir diese beim Import:

Mit Klick auf “Tabelle erstellen” ist das Google Sheet den Quelldaten mit BigQuery verknüpft. Diesen Vorgang wiederholen wir für alle zu importierenden Google Sheets.

— Sheets als temporäre Datenpools nutzen —

Werden Daten dieser Tabellen abgefragt, lädt BigQuery diese Daten aus dem jeweiligen Google Sheet, was bei großen Datenmengen zu Verzögerungen führen kann. Die Google Sheets können aber auch als temporäre Datenpools genutzt werden. Mittels regelmäßiger Abfragen können die jeweils neuen Daten aus den Google Sheets in eine eigens dafür erstellte, interne BigQuery Tabelle übertragen respektive angehängt werden.

Diese Methode funktioniert hervorragend für Daten, die automatisiert mit Tools abgerufen werden können oder in standardisierten Formaten vorliegen. Unsere Lösung für Sonderfälle haben wir am Beispiel der drei Preisvergleichsportale am Ende des Artikels angehängt.

Erstellung der Datenquelle für Looker Studio

Mit SQL können wir die vollständig importierten Daten nicht nur einfach zusammenfügen, sondern gegebenenfalls auch Berechnungen mit oder Modifikationen an den Daten vornehmen. Eine SQL-Abfrage zur Zusammenführung der Daten aus sechs Datenquellen und einer Matching-Tabelle kann sauber formatiert schon mal über 100 Zeilen lang sein.

— Werte vorab modellieren —

Wir verwenden für Abfragen uneinheitlicher Kostendaten WITH Statements, um Feldnamen aber auch manche Werte vorab zu modellieren, damit sie im nächsten Schritt über UNION ALL zu einer homogenen Datenquelle zusammengefasst und anschließend mit LEFT JOIN sauber zugeordnet werden können. Das ist insbesondere dann sehr hilfreich, wenn eine wichtige ID, wie in unserem Beispiel der Kampagnen-Code, nicht als separates Feld in der Datenquelle zur Verfügung steht, sondern aus einem anderen Textfeld extrahiert werden muss.

Das Ergebnis unserer Abfrage schreiben wir in eine neue Tabelle die wir später in Looker Studio als Quelle hinzufügen können. Die Option finden Sie im BigQuery Abfrageeditor unter “MEHR > Abfrageeinstellungen”:

Die Datenquelle für Looker Studio können Sie aktuell halten, indem Sie eine leicht modifizierte Abfrage als geplanten Abfrage speichern, die täglich automatisiert die neuen Daten anhängt.

Hinzufügen der Datenquelle zu Looker Studio

Die fertig vorbereitete Datenquelle verknüpfen Sie aus Looker Studio heraus ganz einfach, indem Sie unter “Daten hinzufügen” den Connector für BigQuery anklicken und anschließend aus Ihrem Projekt und Dataset die neu erstellte Exporttabelle auswählen.

Ab hier können Sie nun wie gewohnt mit der Zusammenstellung Ihres Reports in Looker Studio loslegen. Mit dem großen Unterschied, dass Sie keine Tabellen mehr verknüpfen müssen und die einzelnen Seiten deutlich schneller geladen werden.

In unserem Beispiel haben wir drei berechnete Felder vorgesehen. Diese können Sie natürlich bereits in der SQL-Abfrage zur Erstellung der Exporttabelle ergänzen. Es ist aber auch möglich, innerhalb von Looker Studio einer BigQuery Datenquelle berechnete Felder hinzuzufügen.

Viel Spaß und Erfolg beim Reporting Ihrer Kampagnen-Performance!

Darauf können Sie zählen

Wieviel die Optimierung von Datenquellen mit BigQuery für Looker Studio bringt, zeigt sich vor allem bei umfangreichen Reports.

Unser jüngstes Projekt besteht zum Beispiel aus:

• 123 Diagrammen
• auf 16 Seiten
• aus vier optimierten Datenquellen
• davon 12 Diagramme aus zwei separaten Datenquellen
• und eine zusätzliche Import-Statustabelle mit separater Datenquelle

110 Diagramme und 48 Filter auf 13 Seiten entspringen also nur einer einzelnen Datenquelle.

Im gesamten Reporting werden nur sechs berechnete Felder verwendet. Es wird keine einzige zusammengefügte Datenquelle benötigt.

Die Seiten dieses Reporting laden spürbar schneller als ein vergleichbares Reporting mit direkter Google Analytics und Google Ads Verknüpfung und sogar deutlich schneller als ein weiteres Kundenreporting mit einer Vielzahl direkter Google Analytics Verknüpfungen.

ANHANG

Sonderfälle auf Spur bringen

Manche Daten können nicht standardisiert über Tools abgerufen werden. In dem Fall gilt es, zwei Herausforderungen zu meistern: Zuerst sollen die Daten automatisiert empfangen und eingelesen werden. Anschließend sollen sie verarbeitet und in Form für den weiteren Import in BigQuery gebracht werden. Dabei kann erschwerend hinzukommen, dass die Daten mehrerer gleich zu behandelnder Quellen völlig unterschiedlich ankommen.

Um ein Beispiel zu nennen: Ein Preisvergleicher schickt per E-Mail die Kostendaten pro Tag inklusive der Anzahl an Impressionen und Klicks. Der zweite lädt eine Datei mit einer Zeile pro Klick via FTP auf unseren Server – ohne Kostendaten. Und der dritte stellt eine REST-API zur Verfügung, über die tagesgenau sowohl Kosten als auch Klicks abgefragt werden können, nicht aber die Impressionen.

Am Ende soll ein Google Sheet herauskommen, das folgende Kopfzeile haben könnte:

Um die Daten in dieser Form aufzubereiten und an das Sheet anzuhängen, nutzen wir Google Apps Scripts in zwei Ausführungen: Eine Variante liest die Daten aus den Anhängen der E-Mails, die über ein dediziertes Reporting-Postfach empfangen wurden. Die andere ruft die Daten über REST-APIs ab. Beiden folgt eine einheitliche Export-Funktion zur Übertragung der aufbereiteten Daten in das gemeinsame Google Sheet.

Das funktioniert deshalb so reibungslos, weil Google Apps Scripts sehr unkompliziert mit GMail und Google Sheets interagieren kann. Die via FTP empfangenen Daten senden wir deshalb mittels Bash-Script direkt vom FTP-Server ebenfalls an das Reporting-Postfach und führen sie so der automatisierten Weiterverarbeitung zu.

So kann das ordentlich formatierte Google Sheet auch einfach in BigQuery importiert werden (siehe Abrufen und Importieren der Daten in BigQuery).

Nachfolgend finden Sie einige Beispielcodes dazu.

In Google Sheet schreiben

Fertig aggregierte Daten lassen sich mittels Google Apps Script ganz einfach in ein Google Sheet schreiben.

function writeData(fileID,sheetName,output){
  if (output.length === 0) { return; }
  var sheet = SpreadsheetApp.openById(fileID).getSheetByName(sheetName);
  var lastRow = sheet.getLastRow();
  var lastColumn = sheet.getLastColumn();
  sheet.getRange(lastRow + 1, 1, output.length, lastColumn).setValues(output);
}

E-Mail-Anhänge auslesen

Die zu aggregierenden CSV-Daten lassen sich aus E-Mail-Anhängen ebenfalls sehr einfach mit Google Apps Script auslesen.

function iterateThreads(query){
  var threads = GmailApp.search(query,0,3);
  for(i=0;i<threads.length;i++){
    var subject = threads[i].getFirstMessageSubject();
    var messages = threads[i].getMessages();
    var message = messages[messages.length-1];
    var date = message.getDate();
    var attachment = message.getAttachments({includeInlineImages:false})[0];
    processAttachement(date,attachment); // verarbeitet den E-Mail-Anhang
    GmailApp.moveThreadToArchive(threads[i]);
  }
}

function processAttachement(date,attachment){
  var separator = ";"
  var csvData = Utilities.parseCsv(attachment.getDataAsString(), separator);
  var impressions = 0;
  var clicks = 0;
  var cost = 0;
  for (i=1;i<csvData.length-1;i++){
    var line = csvData[i][0].split(",");
    if (parseInt(line[2]) && parseInt(line[3]) && parseFloat(line[4])){
      impressions += parseInt(line[2]);
      clicks += parseInt(line[3]);
      cost += parseFloat(line[4]);
    }
  }
  prepareData(date,impressions,clicks,cost);
}

Daten abgleichen und in Form bringen

Die ausgelesenen Daten lassen sich anschließend mit ein paar Codezeilen mit den bereits bestehenden Daten abgleichen und vor dem Schreiben in das Google Sheet in Form bringen.

function prepareData(date,impressions,clicks,cost){
  if (checkIfExisting(date) === 0){
    output.push([date,impressions,clicks,cost]); // schreibt in globale Variable
  }
}

function checkIfExisting(date){
  var values = readSheetValues(fileID,sheetName);
  if (!values) { return 0; }
  var filtered = values.filter(function(e){
    if (e.indexOf(date) != -1){
      return 1;
    }
  });
  return filtered.length;
}

function readSheetValues(fileID,sheetName){
  sheet = SpreadsheetApp.openById(fileID).getSheetByName(sheetName);
  lastRow = sheet.getLastRow();
  lastColumn = sheet.getLastColumn();
  if (lastRow === 1) {
    return;
  }
  return sheet.getRange(2,1,lastRow-1,lastColumn).getValues();
}

Unterschiedlich formatierte Daten

Bei unterschiedlichen Formatierungen der eingehenden CSV-Daten kann man sich mit Prozessschleifen behelfen.

else if (comp === "ladenzeile") {
    var date = fileName.match(/(\d{4}-\d{2}-\d{2})/)[1];
    var clicks = 0;
    var cost = 0;
    for (i=1;i<csvData.length-1;i++){
      var line = csvData[i];
      clicks += 1;
      cost += parseFloat(line[5]);
    }
    prepareData(date,comp,0,clicks,cost);
  }

Abruf über APIs

Auch über REST-APIs lassen sich mittels Google Apps Script relativ einfach Daten abrufen.

function idealoMain(){
  Logger.log("Processing idealo");
  const sysdate = new Date();
  const offset = new Date().getTimezoneOffset();
  const today = new Date(sysdate.getTime() - (offset*60*1000));
  today.setDate( today.getDate() - 1 );
  const querydate = today.toISOString().split("T")[0];
  const shopId = "123456789";
  const siteId = "IDEALO_DE";
  const fromDate = querydate;
  const toDate = querydate;
  const cpc = 0.12;
  const access_token = idealoGetAccessToken();
  const idealoClickReport = idealoDownloadDailyClickReport(shopId,siteId,fromDate,toDate,access_token);
  var dataLength = idealoClickReport.findIndex(function(el){ return el[0] === ""});
  for(i=1;i<dataLength;i++){
    var line = idealoClickReport[i][1].split(';')
    var date = line[0].match(/(\d{4}-\d{2}-\d{2})/)[1]
    var clicks = line[1];
    var cost = line[1] * cpc;
    prepareData(date,"idealo",0,clicks,cost)
  }
}

function idealoGetAccessToken(){
	const url = "https://businessapi.idealo.com/api/v1/oauth/token";
	const response = UrlFetchApp.fetch(url, {
		"method": "POST",
		"headers": {
			"Authorization": "Basic ************************************************",
			"Content-Type": "application/javascript",
		},
		"muteHttpExceptions": true,
		"followRedirects": true,
		"validateHttpsCertificates": true,
		"contentType": "application/javascript",
		});
  return JSON.parse(response.getContentText()).access_token;
}





function idealoDownloadDailyClickReport(shopId,siteId,fromDate,toDate,access_token){
	const url = "https://businessapi.idealo.com/api/v1/shops/"+shopId+"/daily-click-reports/download?site="+siteId+"&from="+fromDate+"&to="+toDate;
	const response = UrlFetchApp.fetch(url, {
		"method": "GET",
		"headers": {
			"Authorization": "Bearer "+access_token,
			"Content-Type": "application/json",
		},
		"muteHttpExceptions": true,
		"followRedirects": true,
		"validateHttpsCertificates": true,
		"contentType": "application/json",
		});
  return Utilities.parseCsv(response);
}

Workaround für FTP-Empfang

Um via FTP empfangene CSV-Daten auf die gleiche Weise verarbeiten zu können, schicken wir sie uns mittels BASH-Script als Anhang per E-Mail an unser Reporting-Postfach.

#!/bin/bash
inotifywait -m -r /var/www/********/htdocs/******** -e create -e moved_to |
    while read dir action file; do
 	sleep 10
	subdir="main"
	needle="\/(.[^\/]*)\/$"
	if [[ $dir =~ $needle ]]
	then
	subdir="${BASH_REMATCH[1]}"
	fi
        echo "The file '$file' appeared in sub-directory '$subdir' via '$action'"
        echo "Datei '$file' von '$subdir' via FTP empfangen ." | mutt -x -s "******** $subdir reportings" -a $dir$file -- ********@adtraffic.de
	today=$(date +"%Y%m%d")
	mkdir /var/www/********/htdocs/********/$subdir
	mkdir /var/www/********/htdocs/********/$subdir/$today
	mv -f $dir$file /var/www/********/htdocs/********/$subdir/$today/$file

The post Google Looker Studio Reports: Ladezeiten deutlich verkürzen appeared first on adtraffic.

Berlin, im April 2022. Daten sind das neue Gold! Daten sind das neue Öl! Daten sind das neue Wasser! Diese Vergleiche sind hinlänglich bekannt und verdeutlichen: Daten sind sehr wertvoll. Aber welchen Daten können wir vertrauen? Am besten schenkt man nur Daten Vertrauen, die man selbst erhoben hat oder bei denen man in der Lage ist, sie zu prüfen. Im Folgenden veranschauliche ich anhand von Meta (Facebook & Instagram) und Google Ads, wieso Skepsis gegenüber den erhobenen Daten angebracht ist.

Wie Agenturen und Plattformen täuschen

Im (Online) Marketing gibt es viele sogenannte Vanity Metrics. Also Zahlen, die vermeintlichen Erfolg suggerieren, aber letztlich wenig Aussagekraft haben. Weit vorne dabei sind auch die KPIs der Plattform Meta (Facebook & Instagram). Im Business Manager von Meta kann man über 100 unterschiedliche KPIs auswerten. Diese KPIs werden oft fehlinterpretiert oder bewusst falsch ausgelegt.

Die meisten Kennzahlen davon sind so aussagekräftig, wie wenn H&M messen würde, wie viele Personen ein Kleidungsstück angesehen, angefasst und anprobiert haben und davon das Verhältnis ausrechnen. Bitte nicht falsch verstehen – das wäre sicherlich interessant und man kann anhand der Daten vieles interpretieren und manches im Prozess verbessern. Wenn alle im Geschäft das Produkt nur anfassen und niemand probiert es an, dann hat das Kleidungsstück wohl ein unangenehmes Material. 

Man darf sich von den „soften“ Kennzahlen, die oft sehr hoch ausfallen, nicht blenden lassen und muss wissen, wie diese zu verstehen sind. Meta trackt Interaktionen und man kann diese für die Auswertung einer Anzeige heranziehen. Man sollte aber dabei im Hinterkopf behalten, dass die Hälfte der Interaktionen von eigenen Mitarbeitern oder Nutzern stammt, die einfach alles liken. Übrigens: Interaktionen sind nicht nur Likes oder Kommentare, auch ein Fotoaufruf oder 3-sekündige Videowiedergaben werden als Interaktion gemessen. Die Definition der jeweiligen Kennzahl erfährt man mit einem „Maus-hoovern“ über die Bezeichnung.

Wirklich wichtig sind den meisten Unternehmen „harte Zahlen“ wie Käufe, Umsatz oder qualifizierte Leads und vielleicht noch die erzielten Besucher der Webseite.

Warum trackt Meta so viele Käufe?

Viele kennen das: im Business Manager wird im Vergleich zum eigenen CRM oder Google Analytics ein Vielfaches an Käufen ausgewiesen. Die Ursachen dafür sind vielfältig, mit den richtigen Einstellungen kann man sich jedoch den tatsächlichen Zahlen annähern. Wenn kein Fehler beim Pixel oder Tracking vorliegt, hängt das maßgeblich mit den Attributionseinstellungen zusammen. Dort legt man fest, wann ein Kauf der Facebook-Anzeige zugerechnet wird. Man wählt den Zeitraum, 1 oder 7 Tage und ob der Kauf nur bei Ansehen der Anzeige oder bei Klick der Anzeige zugerechnet werden soll. Hinzu kommt, dass die Kennzahlen Schätzwerte sind.

Ein schönerer Ausdruck dafür ist Modellieren. Spätestens seit Corona ist das jedem ein Begriff. Modellieren ist sowohl bei Corona als auch bei Meta selbstverständlich sehr hilfreich. Denn man kann damit Tendenzen erkennen, bewerten und schlussfolgern. Wichtig ist, nicht zu vergessen, dass Schätzwerte und Modellierungen nie die Wahrheit sind und deshalb auch nicht als solche verstanden werden sollten.

Dass im Onlinemarketing heute so viel modelliert wird, haben wir nicht Corona, sondern den verschärften DSGVO-Richtlinien und dem IOS14-Update zu verdanken. Seitdem können deutlich weniger „echte“ Daten getrackt werden.

Wie kommen die Schätzwerte bei Meta zustande?

Wie die Schätzwerte zustande kommen, ist nicht genau bekannt, denn dahinter verbergen sich komplexe Algorithmen, die laut Aussagen von hochrangigen Meta-Mitarbeitern heute niemand mehr versteht. Man kann annehmen, dass Meta bei den Schätzwerten ähnlich konservativ vorgeht, wie man es von den Automobilherstellern oder anderen Werbeversprechen kennt: den Verbrauch von 4,8L auf 100 km kann man nicht einmal auf einer optimalen Teststrecke erreichen. Tatsächlich sind es bei 80 auf der Landstraße dann im besten Fall 6,4L auf 100 km.

Tipp:

Vertrauen Sie nicht blind den Plattform-Daten, sondern überprüfen Sie diese immer mit einem oder mehreren Drittanbieter Tools, wie bspw. Google Analytics. Die Wahrheit in den Daten zu finden, ist unmöglich. Mit dem richtigen Tracking, Attributionseinstellungen, Datenabgleichen und Reportings kann man sich dieser annähern. Vergessen Sie bei den vielen Plattform-Daten nicht die eigenen Website-Daten (First Party Daten) zu nutzen und auszuwerten, denn diese tragen meist mehr zum wirtschaftlichen Erfolg bei.

Auch die Metriken bei Google Ads sollte man kritisch hinterfragen. Überraschend dabei ist die KPI „sichtbare Impressionen“ bei Display Anzeigen. Das bedeutet: unter den „Impressionen“ befinden sich auch Anzeigenausspielungen, die niemand gesehen hat. Manche mögen behaupten, das sei bei Display Bannern üblich. Dann kann man als Anbieter von TV-Werbung auch behaupten, mein Fernsehspot hatte 40 Mio. Impressionen – aber nur 10% davon waren wirklich „sichtbare Impressionen“, also in der Realität gesehene, denn 90% der Fernseher waren ausgeschaltet. Übrigens: auch bei Google Ads werden die Kennzahlen modelliert – auch hier zeigt unsere Erfahrung, dass die Werte tendenziell deutlich besser ausfallen als die überprüfbaren Daten.

Daten richtig analysieren

Über Datenanalyse könnte man ein ganzes Buch schreiben. Ich möchte an der Stelle nur zwei Beispiele für Fehlinterpretationen aufzeigen: 

Bei einer Display Ads Kampagne hatten wir als Zielgruppe weiblich 25-40 J. hinterlegt und diese auch entsprechend erreicht. Nach einigen Tagen haben wir genauer analysiert, wo die Anzeigen ausgeliefert wurden – nämlich in Spiele Apps für Kinder. Die benutzen das Handy der Mama und klicken versehentlich auf die Anzeige, wodurch Kosten entstehen. Vermeintlich wurde die Zielgruppe erreicht, bei genauem Überprüfen aber dann doch nicht.

Tipp: 

Bei Google Ads Display Ads den Reiter Placements genau analysieren. Dort bekommt man eine Liste mit Webseiten, mobilen Apps und Videos präsentiert. Nicht passende kann man dort nach Überprüfung ausschließen. Im Internet gibt es auch vorgefertigte Listen um bspw. Dating- oder Spieleseiten auszuschließen. Expertentipp: Auch automatisierte Skript-Lösungen sind möglich.

Das andere Beispiel bezieht sich auf einen B2B-Kunden. Wenn nicht genügend Leads zur Optimierung erzielt werden, wird häufig auf Soft-Conversions wie Sitzungsdauer zurückgegriffen und optimiert. Das bedeutet, dass bspw. eine Verweildauer von 60 Sekunden auf der Webseite als Conversion getrackt und anschließend auf diese Conversion optimiert wird. Bei genauerer Analyse ist aufgefallen, dass sich viele Studenten auf der Webseite über das Thema informieren und entsprechend lange auf der Seite aufhalten. Der Algorithmus von Google folgerte daher daraus, es wäre sinnvoll auf Studenten zu optimieren, die jedoch überhaupt nicht zur Zielgruppe gehören. Das Conversion-Tracking haben wir bereinigt und Studenten bei den Anzeigenschaltungen ausgeschlossen.

Tipp:

Tracking regelmäßig hinterfragen. Nur mit der richtigen Datenbasis kann man auch richtig optimieren.

Ein lückenloses Tracking und damit hundertprozentig richtige Daten wird man im Marketing nie erreichen. Aber man kann sich annähern. Mit dem Wissen, dass Agenturen und Plattformen meist nicht objektiv sind, sondern Daten erheblich positiver auslegen als sie sind, sollte man die Kennzahlen kritisch hinterfragen. Werbeversprechen von Agenturen wie ROAS +300% sind entweder falsch, nicht überprüfbar oder nicht adaptierbar und damit wenig seriös.

Sie brauchen Unterstützung im Bereich SEA, Social Media Marketing, Tracking oder Datenanalyse? Kommen Sie gerne auf uns zu!  

Fragen oder Kritik zum Artikel sind willkommen!

The post In Data We Trust? – können wir den Daten der Online Marketing Plattformen vertrauen? appeared first on adtraffic.

Wir stellen uns dieser unvermeidbaren Entwicklung in eine immer intransparentere Online-Werbewelt. Als spezialisierte Experten in den Bereichen SEA, SMA und Tracking sehen wir unsere Aufgabe vor allem darin, unseren Kunden die notwendige Transparenz weitgehend zu erhalten. Das erreichen wir unter anderem mithilfe von Automatisierung, Datenmodellierung und individuellen Reportings.

Kompakt greifbar

Unsere Idee und Erfahrung sowie unsere Leistung und Herangehensweise haben wir mit Unterstützung unseres Partners pixelperfektion in unserer neuen Unternehmensbroschüre kompakt greifbar gemacht. Gerne senden wir Ihnen ein Exemplar auf Anfrage zu.

Parallel dazu haben wir am diesjährigen „Ranking Performance-Marketing 2022“ teilgenommen. Dazu hat der Münchner HighText Verlag[2] von 70 Agenturen die im Jahr 2021 verwalteten Performance-Marketing-Budgets zusammengetragen und die Ergebnisse online veröffentlicht. [1]

Die adtraffic konnte sich mit einem Gesamtbudget von 12,3 Mio. Euro einen guten Platz im oberen Mittelfeld des deutschlandweiten Rankings sichern. In unserem Spezialgebiet “Search Engine Advertising” erreichten wir sogar Platz 19 von 53 und verpassten so nur knapp das obere Drittel der teilnehmenden Agenturen. Auch für das “Teil-Ranking Automobil” qualifizierten wir uns und landeten mit 2,7 Mio. verwaltetem Werbebudget auf Platz 4 von 6.

Große Budgets und unkonventionelle Arbeitsweise

Wir freuen uns sehr über unsere Ergebnisse in den Rankings. Es zeigt, dass auch vermeintlich kleine Agenturen große Werbebudgets erfolgreich verwalten und performant skalieren können. Für uns ist es zudem eine Bestätigung unserer eher unkonventionellen Arbeitsweise: Unser Team arbeitet remote aus sechs Orten von Bruckmühl bis Göteborg und setzt bei vielen Detailaufgaben auf Automatisierung und Datenmodellierung. Damit sind wir in der Lage, auch sehr umfangreiche und feingliedrige Kampagnen in Werbekonten abzubilden und zu optimieren.

Quellen:

[1] onetoone.de/performance-ranking/

[2] Der HighText Verlag veröffentlicht 14 verschiedene Unternehmens- und Branchen-Rankings der New Media Branche [3] und ist unter anderem Betreiber der Branchenportale iBusiness und ONEtoONE.

[3] ibusiness.de/rankings/

The post Ranking Performance-Marketing 2022 appeared first on adtraffic.