If you’re using server-side Google Tag Manager, Google (Advanced) Consent Mode and you’re collecting hits to Google Analytics 4, you might have noticed something odd happening when switching consent to granted state.It looks as if your page_view hits as well as any other hits marked as “Conversions” (or key events now, I guess) are automatically redispatched to the server-side Google Tag Manager endpoint when consent is granted!This sounds incredibly useful.

This will be a quick tip, but it’s here to correct my previous statements in the comments section of different articles on this blog.When using Advanced Consent Mode, Google Analytics 4 collects hits when consent is in "denied" state. These hits have a lot of parameters stripped off them, including identifiers like the Client ID and the Session ID.The hits will not surface in reports directly, but they will instead go through a modeling process to enrich the reports once modeled.

Simmer has just released the Technical Marketing Handbook.It’s a free online resource, formatted as a mini-course, designed to walk the reader through the different disciplines and concepts that fall under the banner of “technical marketing”. And yes, we spend the introductory chapter explaining what that term means to us. In total, we wrote 9 chapters, each with 3 topics, for a total of around 77,000 words. For reference, that’s about as many words as in the first Harry Potter novel.

**Last updated March 7, 2024. Clarified that you do NOT need to resend hits when consent is granted, if those hits were collected on the same page when consent was denied. Google’s Consent Mode continues to be a hot topic, especially since in 2024 it will be required to implement Consent Mode in case a website or app is collecting data for audience building or remarketing with Google’s advertising services.

As my LinkedIn inbox graciously reminded me that I’ve been working on Simmer for a full three years now, I’d like to share a couple of observations about education – particularly in the world of technical digital marketing.Online courses are an interesting vehicle for education. The medium offers a plethora of different approaches to knowledge transfer, student assessment, and collaboration. It seems like a no-brainer in today’s day and age, particularly for someone who wants to build a platform that scales beyond in-person tuition.

This is a template for deploying Google tags’ Consent Mode functionality. It lets you deploy Consent Mode with both the “default” and “update” commands.

I am fortunate to share another guest post by Arben Kqiku, Digital Analyst at Assura.Last time, Arben graced this blog with a comprehensive love letter to R as an example of the power of this programming language.This time, he’ll add even more fancy tools to the toolkit to help you build a data pipeline in the Google Cloud Platform to join your Google Ads and Google Analytics 4 data together.

In a recent update to server-side tagging in Google Tag Manager, Google switched the default deployment of a server-side tagging backend from Google App Engine to Google Cloud Run.Now, when you create a new container and choose the automatically provisioned tagging server option, this service will be created in Google Cloud Run instead of in Google App Engine. While I’ve written about Cloud Run before, this update gives me an opportunity to review what actually happens when you provision a Cloud Run environment, how you can upgrade it, and how you can add enhancements such as multi-region load balancing to it (with ease, I might add!

Google is going all-in with Google Tag. We’ve already seen the consolidation effort through products like Google Analytics 4, and now Google is extending the merging of the tagging stack into Google Tag Manager, too.I’m referring to the new Google Tag that has replaced Google Analytics 4 configuration tags in your Google Tag Manager containers.With this release, all your old GA4 configuration tags have been auto-migrated to the new Google Tag.

One of the big pain points in configuring Google Analytics 4 through Google Tag Manager has been the difficulty of setting up event parameters, user properties, and settings across a range of tags.Well, we can finally get rid of our clumsy Config tag sequencing hacks because Google has released two new settings variables that mimic how the Google Analytics Settings Variable used to work in Universal Analytics.The new variables are:

Today marks the date of exactly 10 years of marriage to my wife, my friend, the loving mother to our children, and my business partner at Simmer. And yes, they are all the same person – I’m that lucky!Thank you, Mari, for everything.

Content warning: introspection, parenthood, “Floating Butt”.When Benjamin (our first child) was born, my life as an individual was unraveled.With every bellow from the newborn’s lungs, I could feel my personal agency slipping away from me.From that magical moment onwards, I’ve been gripped by the polarizing emotions of parenthood.At any given time, I’m galvanized by fear for the well-being of my children, or existentially deadlocked by the calamities of all the possible (terrible) futures for this planet, or (figuratively) high from the amazing content and purpose my children bring to my life.

In January 2020, when Google Tag Manager’s server-side tagging was first introduced to the general public at SuperWeek, I wrote a flurry of tweets, sharing my vision of a server-side tagging future.In one of the tweets, I discussed how you could do these: Hit validation and fixing before the hit is sent to the endpoint PII and privacy controls for the requests before dispatch Fast forward to today, over three years later, and we are finally treated to a feature that grants us scalable controls to properly interrupt data flows within server-side GTM.

I owe my career to Google Analytics.Whatever success I have achieved over the past 15 years or so can be directly attributed to my work with GA and, by extension, other tools in the Google stack.Now, Universal Analytics is about to be turned down.It fills me with a sense of nostalgia and pining for past, simpler times.When I cast my mind back, a scattering of memories emerges in my mind:

The FPID cookie is what server-side Google Tag Manager would prefer to use for your Google Analytics 4 tracking.It’s a cookie set in the HTTP response from the server, and it’s flagged as HttpOnly, which means it’s only accessible by a web server running on the domain on which it was set.There’s nothing wrong with the technology, and I do recommend that server-side setups toggle it on by default.

Server-side tagging is all about control. Being able to intercept, modify, and even block requests as they come in before they are dispatched to their actual endpoints is extremely valuable.The built-in Google Analytics 4 tag template has options for modifying event parameters and user properties in the Google Analytics 4 request, but did you know you can use these options to modify some of the fields as well, such as Client ID, User ID, and event Engagement Time?

While Measurement Protocol for GA4 is still rather, well, rough, it can be used to augment existing collection quite nicely. Recently, I wrote an article that discussed the nuances of session attribution with Measurement Protocol.One of the pain points of any data ingestion setup is how to debug it. Measurement Protocol hits are not automatically surfaced in GA4’s DebugView.In this article, I’ll show you how to make those hits pop up in the debug stream.

In this article, I’ll try to clarify the understandably murky Measurement Protocol functionality in Google Analytics 4.Measurement Protocol is a way to send events to Google Analytics 4 directly from a machine capable of sending HTTP requests (such as a web server). It’s an alternative collection method to the client-side libraries of Google Tag and the Firebase SDK. Measurement Protocol in GA4 is very different from its predecessor in Universal Analytics.

This is a guest post by Sebastian Pospischil, Evangelist Digital Analytics at TRKKN. All credit for the solution goes to him. The Summary section is the only one authored by Simo Ahava. You know the deal.Each and every day, clients reach out to you asking for custom click tracking for this call-to-action on that slider, or that button in this section of a page. They reach out to you because such things cannot be answered out of the box in Google Analytics 4.

If you recall, in February 2019, Apple published a post on the WebKit blog, which introduced version 2.1 of their Intelligent Tracking Prevention browser mechanism.In this version, Safari (and soon all WebKit browsers, including browser apps on iOS and iPadOS) placed an expiration limit on browser cookies set with JavaScript. It was no longer possible to set the expiration date further than 7 days in the future.In a recent 2022 release (I don’t have the exact date or version number), WebKit has now modified this mechanism to no longer set an expiration cap on JavaScript cookies.

I have been a strong supporter of server-side tagging, in particular Google’s server-side tag management solution.I admire the way it seeks to readjust the balance of control that typically has been in favor of the marketing vendors whose JavaScript libraries have been free to wreak havoc in the user’s browser. By inserting a buffer between the user and the vendor, the owner of the server-side tagging setup can take control over what data the marketing vendors can actually process of the user.

This is a guest post – the first one in a long time! The foreword and summary are written by me, Simo, and the rest is by my esteemed guest author.How fortunate was I to have been contacted by Arben Kqiku, Digital Marketing & Data Manager from comtogether. Arben is one of our many Simmer students, and he’s walked through the Query GA4 Data In Google BigQuery course, learning a lot along the way.

With the sunset announcement of the Universal Analytics service, it certainly does seem like a waste of time to write articles about it.However, a recent update to Google Tag Manager is an interesting one and should provide relief to those Google Analytics users who are set on double-tagging their sites for both Universal Analytics and Google Analytics 4 and who want to make use of GA4’s new Data Layer schema.

For the longest time, Google has been working towards consolidation of their products to build a unified tagging platform.Products that are instrumented (or associated) with “tags” would fall under this umbrella. These comprise tools like Google Tag Manager, Google Ads, Google Optimize, and, of course, Google Analytics.If you’ve been peeking under the hood, you might have noticed how all the tools listed above already run through the gtag.js library.

With certain types of HTTP requests, the web browser might first dispatch a request with the OPTIONS method, also known as a preflight request.The purpose of the preflight request is to “check” with the web server that it’s equipped to handle the type of cross-origin request the browser wants to dispatch.If the server doesn’t handle this preflight request, or if it returns a response that doesn’t agree with what the web browser wants to actually dispatch, the check fails and the browser refuses to send the actual request.

Server-side Google Tag Manager has an excellent Preview mode, which lets you inspect incoming requests, monitor the event data object, view console messages, and identify outgoing requests, among other things.To enable this Preview mode on the web, you simply need to click the Preview button in the container, after which any requests sent from the same browser instance will be automatically shown in the Preview mode window.However, what about if you want to send requests from another browser?

Seven years ago, I wrote on my former employer’s (the amazing Reaktor) blog a tongue-in-the-cheek article titled 10 Truths About Data.Looking back on it today, I’m still proud of the handiwork, but I can’t help but think that some of the truths were wasted just to reach the magic number 10.So, today, I want to revisit these truths and provide a rehashed version for you, my dear reader.

If you want to manually install server-side Google Tag Manager on App Engine in the Google Cloud Platform, you are of course welcome to do so.The main benefits of doing this are that you get to choose the region where App Engine is deployed and that you can use existing project resources instead of having a new project automatically created for you.However, to run the script without errors, there are a number of things you need to enable first.

With asynchronous variables recently released in server-side Google Tag Manager, it’s time to dig into data enrichment flows using another release from the Google team.* drum roll *We have a new Google Cloud Platform API!It’s fast. It’s sleek. It’s beautiful. It’s Firestore! Firestore is a NoSQL, transactional, and scalable database that offers near-real-time write/read and sync operations for data.In practice, it’s a great way to enrich and widen the data that you pass through your Server container.

OK, that’s one unappealing title for a blog post, but rest assured that the content more than makes up for this obscurity.Recently, my favorite toy in the world, Google Tag Manager’s server container, introduced the capability to handle asynchronous operations in variables.This is done through a JavaScript interface known as Promise. A Promise is a way to run code in JavaScript without knowing what its eventual value will be.

While Google App Engine, the default implementation pattern of server-side Google Tag Manager, is straightforward to setup with the automatic provisioning steps, it’s certainly not the only way to deploy the server. You can set it up in Amazon AWS (this blog) You can set it up in Microsoft Azure (this blog) You can set it up with Cloud Run (Mark Edmondson’s blog) In fact, the manual setup guide gives you the details on how to deploy a Google Tag Manager Server in any environment that runs Docker.

One of the key skills for anyone working with web analytics and tag management is understanding how to identify where things went wrong, why they went wrong, and ideally how to fix them.There are plenty of excellent browser extensions for helping you debug, and we’ll discuss these in the guide, too. But most of all we’re going to use browsers’ own developer tools, as they are always the best source of truth for anything that happens within the browser window.

Although most of Server-side Tagging in Google Tag Manager revolves, quite rightfully, around Clients, there’s still plenty of value to be derived from tags, too.Naturally, the most common use case for server-side tags is to map the incoming requests to the Server container (filtered through Clients) and dispatch them to their respective endpoints.But in addition to dispatching HTTP requests, tags can do so much more.In this article, I’ll share with you a neat way how to utilize tags to manipulate the HTTP responses the Server container sends back to the request source.

To continue my extensive collection of Google Tag Manager’s server-side tagging articles, in this guide I’ll walk you through how to set up a Server container in Microsoft Azure’s App Service platform.For my previous guides on manually provisioning a Server container, follow these links: Amazon AWS (Elastic Beanstalk): Deploy Server-side Google Tag Manager In AWS Google Cloud (App Engine): Provision Server-side Tagging Application Manually Azure’s App Service is similar to AWS Elastic Beanstalk and GCP App Engine, in that it lets you create a web application from scratch with minimal effort.

Setting up cross-domain tracking in Google Analytics 4 has been well-documented.The main departure from Universal Analytics is how cross-domain measurement is something you configure through the Google Analytics user interface rather than through implementation and JavaScript.While this approach is obviously beneficial especially for those who lack the know-how or the resources to configure the JavaScript trackers, it does lead to problems, too.In this article, I want to tackle these edge cases.

For many, it seems, one of the most important justifications for server-side Google Tag Manager is its resilience to ad and content blockers. After all, by virtue of serving the container JavaScript from your own domain, you escape many of the heuristic devices today’s blocker technologies employ.Well, I’ve gone on record over and over again to say how this is poor justification for using server-side GTM. By circumventing the user’s wish to block scripts, you are disrespecting them and forcing their browser to download scripts that they wanted to avoid downloading in the first place.

Google has released the Google Ads Remarketing tag for server-side tagging in Google Tag Manager.Functionally, it’s remarkably similar to the Conversion Tracking tag they released previously. In fact, you should go ahead and read that article first, so that you have an understanding of how Google Ads tracking works through Server containers!Follow this link to read the official documentation.In this article, I’ll walk you through how to set things up, and I’ll also provide an overview of how it works.

The FPID cookie in server-side tagging for Google Tag Manager is an HttpOnly, server-managed ID cookie that’s designed to replace the JavaScript-managed _ga cookie used by Google Analytics 4 and Universal Analytics.For more details about the cookie itself, check out my previous article on FPID.In that article, I mentioned one caveat for adopting FPID being the fact that cross-domain tracking will not work.I mean, how could it? FPID is an HttpOnly cookie, which means it’s not available to JavaScript in the browser.

One of the biggest blockers for Google Tag Manager’s server-side tagging to slip out of beta is Google Ads. Until server-side tagging supports a solution for both conversions and remarketing capabilities to be reproduced server-side, it’s unlikely that Server containers will lose their beta label. While I can’t say what will happen to the beta label now, the fact is that Google Tag Manager has now released support for Conversion tracking using server-side tagging.

Since Google Tag Manager released the manual setup guide for server-side tagging, my mind has been spinning with the idea of walking through the deployment into Amazon’s AWS.I personally prefer Google Cloud Platform over AWS, because I think it’s so much more user-friendly. Even though in this guide we’ll be utilizing one of the simplest AWS services, Elastic Beanstalk, the deployment is still much more complex than if you were to use GCP’s App Engine.

Last updated 1 December 2023: New consent signals addedEver since Google Analytics released the first features of consent mode, I’ve been anxiously waiting for news about a more tightly-knit integration with Google’s preferred implementation solution: Google Tag Manager.In a recent release, Google released a veritable cornucopia of new features that should assist in determining and implementing consent not just across Google tags, but any tags running in the container.

This tag adds measurements for Core Web Vitals (LCP, FID, CLS), and pushes them into dataLayer once each is collected.

A variable template with which you can access the key-value pairs that were present in the dataLayer.push() that caused the tag to fire.

Last updated: 18 October 2021. Peview works now with the proxied container even if the container ID is overridden.. While server-side tagging already has a wonderful built-in Client for proxying the Google Tag Manager container via your own first-party domain, it’s not perfect.The main issues are that it doesn’t let you delimit access on a per-origin basis, so requests for the allowlisted container IDs can be sent from anywhere, and that it doesn’t let you freely choose the path via which the container ID is loaded.

This Server container tag template can be used to set (or rewrite) any browser cookie in the HTTP response.

I’ve written about Google’s reCAPTCHA v3 before. It’s a verification API, which analyzes the signals fed into it and returns a bot score, based on how “bot-like” the hits are.It’s a great way to validate whether or not to collect data from certain sources that exhibit bot-like behavior. You’ll want to ignore those in your analytics tools, for example, as they tend to add a lot of (unrealistic) noise to the data set.

The automatic provisioning process of the Google Tag Manager server-side tagging service is extremely useful.With just a few clicks of the button, you can have a fully functional (albeit limited to testing use) server-side tagging endpoint on the Google Cloud Platform (GCP). For a video overview of the automatic deployment, see this video. However, the automatic provisioning process creates a new Google Cloud Platform project and, at the time of writing, always deploys the App Engine application (on which the tagging server runs) in the us-central-1 GCP region.

With server-side tagging, you can send any types of HTTP requests to the Server container. The Server container parses these, fires up container instances, and sends the data onwards to first-party data stores and third-party vendors alike.Often these requests contain URL strings encoded in query parameters. A prime example is the document location parameter in Universal Analytics requests.Server-side Clients would parse these URL strings and convert them into the format required by the event data object.

The URL Parser (Server Container) variable template can be used to parse URL parts out of any URL string passed as input. It works by default with the page_location field in the event data object.

Use this Server container template to set up a monitoring system for Google Tag Manager.

Facebook has now officially released their Conversions API tag template for server-side tagging in Google Tag Manager.With this tag template, you can create a server-side tag that fires with any Client designed to parse requests into a unified event model. One such Client already exists, and every single Server container has it built-in: the GA4 Client. If you haven’t yet deployed a Server container, check out this video walkthrough for more details on how to do it.

One of the biggest perks of working with server-side tagging is that you can establish a first-party context between the site sending the data and the server-side tagging endpoint itself.This leads to many benefits, including improved control of the data streams, the possibility to set cookies that extend beyond ITP’s restrictions, and reduced stress on an already very likely overloaded Content Security Policy.In this article, I’ll show you how to map multiple custom domains to your Google Cloud Project application.

Ever since it was released that server-side tagging in Google Tag Manager would run on the Google Cloud Platform stack, my imagination has been running wild.By running on GCP, the potential for integrations with other GCP components is limitless. The output to Cloud Logging already introduces interesting pipeline opportunities, but now it gets even better.It’s finally possible to write directly to Google BigQuery from a Client or tag template!

There’s a new custom variable template in town! The Data Layer Picker template lets you create variables that have a singular, exceptional (in Google Tag Manager’s context, at least) purpose:You can access the keys and values that were in the object pushed into dataLayer itself. And … that’s it! Read on to understand why this might be useful.Tip 123: Direct access to the dataLayer.push() If you know your Data Layer Variable, you’ll know that it comes in two versions.

Use the sha256 Hasher template to generate a SHA256 hash (encoded with base64 or hex) of any input string

One of the largest costs in a server-side tagging can be logging. Google warns about this in their official documentation, and it’s definitely something to keep a keen eye on if your server-side endpoint processes enough data per month.How much should it process for logging to become an issue? It depends, but you could start seeing some impact once the endpoint processes >1 million incoming requests per month. The best way to find out if logging is a problem is to visit the Billing dashboard in your server-side tagging Google Cloud project and check what the portion of Log Volume is in your monthly costs.

This will likely be the shortest blog article I have ever written, but I have just one short thing to say:SIMMER IS LIVE!Simmer is a new online course platform, where we bring technical marketing courses to your computer (or mobile device) screen with a straightforward, task-based approach.Our first class is aptly Server-side Tagging In Google Tag Manager, and it is open for enrollment right now, all the way until March 14th.

This is an unofficial template for the AdForm Tracking Point. You can use it to load the SDK, initiate the tracking point, and to send page- and order-level data to AdForm.

Updated 3 March 2023: Added a checkbox to the template to enable collecting FCP, INP, and TTFB metrics, too.. Core Web Vitals is described on the dedicated web.dev resource as (emphasis mine): “Core Web Vitals are the subset of Web Vitals that apply to all pages, should be measured by all site owners, and will be surfaced across all Google tools.” Recommended Core Web Vitals thresholds - from https://web.

One of the big omissions, at least for now, in Google Analytics 4 is the customTask. It is unfortunate, but no such mechanism exists in the client-side SDKs.This means that you won’t be able to do all the magical things that customTask enables in Universal Analytics. One of the biggest headaches is how to collect extremely useful fields such as the Client ID, as these are not available by default in the Google Analytics 4 reporting interface.

At one point in the turbulent year of 2020, you might have gasped in surprise when looking at the preview interface of Google Tag Manager. No, I’m not talking about the new preview mode interface.Instead, I’m referring to how the Click Element and Form Element built-in variables would now display a CSS path string rather than the expected [object HTMLDivElement] (or equivalent). There was good and bad in this update.

This tag writes into dataLayer selected default and custom fields set with tags that utilize the gtag.js library; Google Analytics 4, for instance.

For years, I’ve resisted the urge to start a newsletter. My reasoning was always very simple: I want this site to be about knowledge sharing and nothing else. Building a mailing list can really get in the way. I’m sure you’ve noticed it with your favorite content creators. You can practically pinpoint the moment in time when it became more about followers and less about content.I’m also personally allergic to websites that relentlessly try to get you to sign up or to buy something, and I’ve been proud that this blog has never been about pushing a product, service, or agenda.

This tag stores the Transaction ID provided by the user in a browser cookie and/or localStorage.

Designed to work with the Transaction ID Logger tag template, this variable template reads Transaction IDs stored in a browser cookie or localStorage.

This variable template takes an Enhanced Ecommerce products/impressions/promotions array as an input, and outputs it in the updated “items” format for Google Analytics 4 Ecommerce.

With the introduction of server-side tagging in Google Tag Manager, the variety of things you can do with your own server-side proxy is mind-boggling: Reduce client-side bloat by consolidating data streams and distributing them to vendor endpoints server-side. Improve data security by adding safeguards and validations to prevent harmful data from being sent to vendor endpoints. Enrich data server-side, by combining the incoming data stream with data from APIs and data stores that you own and control.

Intelligent Tracking Prevention is the name of the tracking prevention mechanism implemented in WebKit and enabled in Safari and all major browsers running on the iOS platform. I’ve written about it on this blog, and the CookieStatus.com resource is something you should bookmark for further reading.The purpose of ITP is to prevent tracking tools’ access to data stored and processed in the browser. This involves things like blocking all third-party cookies and restricting the lifetime of first-party cookies.

On the surface, tracking events in Google Analytics 4 (GA4) is fairly simple. Events are, after all, pretty much the only thing you can collect in GA4.It’s easy to get tied down with endless comparisons to Universal Analytics, though. While I’m steadfastly opposed to the idea that GA4 should resemble Universal Analytics, it’s still important to cleanse the palate and approach GA4’s event tracking with an open mind.There are some comparisons that can be drawn between the new and the old, but what GA4 might lack in some features and use cases, it more than makes up for this with a more flexible data structure.

This is an unofficial template for the Facebook Pixel. You can use it to load the SDK, initiate the pixel(s), and to send custom and standard events to Facebook with any custom properties and user attributes you wish.

This is an unofficial template for AudienceProject’s UserReport tag.

The release of bulk actions in the Google Tag Manager user interface was very welcome. For years, GTM users had been struggling with a somewhat crippled workflow of item-by-item management.This release is even more impressive with the most recent update to it: bulk actions with TRIGGERS. You can now select multiple tags and attach one or more triggers (or exceptions) to them. Or, conversely, you can use the feature to remove triggers (or exceptions) from tags.

Last updated 17 March 2023: Item-scoped Custom Dimensions are now available in Google Analytics 4. This is an implementation guide for Google Analytics 4. The guide is aimed at Google Tag Manager users and has been designed to complement the official documentation. A thing to keep in mind is that Google Analytics 4 (GA4) is still very new. The Google Tag Manager integration is still in its infancy, and implementation places a lot of responsibility on accurate tagging and proper dataLayer instrumentation.

Last updated 12 February 2021: Clarified how Preview is shared. Your favorite tagging platform, Google Tag Manager, now comes equipped with a completely revamped preview mode experience.Gone are the days of having to minimize the debug pane to prevent it from hogging up screen real estate on the website.Gone are the days of having to use browser extensions to see what happened in GTM on previous page loads.

Note! This is about the original version of Consent Mode. While the content is still very valid and you should read through it to understand how it works, Google has since released a “V2” update with additional consent signals. You can read about Consent Mode V2 here. . Not too long ago, Google announced a new consent mode for Google tags. It allows you to build a mechanism where Google’s tags parse, react, and respond to the consent status of your site visitors.

It’s lovely to see small, incremental, quality-of-life improvements to Google Tag Manager amid the behemothian feature releases such as custom templates in 2019 and server-side tagging in 2020.This time around, we’ll take a look at the upgraded search functionality of the Google Tag Manager user interface, which makes search an actually useful tool. In addition to this, we’ll take a look at one of the most requested features in the history of Google Tag Manager, which we finally have access to: bulk actions!

Apple’s annual Worldwide Developer Conference in late June this year included a couple of big announcements around Apple’s approach to privacy in their software.The new Privacy Report in Safari 14 (on all platforms) uses DuckDuckGo’s tracker radar list to detail which of the most prominent tracking-capable domains have been flagged by Intelligent Tracking Prevention (ITP) in the user’s browser.Apple also announced that the WKWebView class, which all iOS and iPadOS (the operating systems for iPhones and iPads, respectively) must use, will include WebKit’s ITP mechanisms on by default.

Exporting a container in Google Tag Manager can have many purposes. From backing up Google Tag Manager versions to creating and distributing repositories of useful container snapshots, the container export is one of the most useful non-tagging-related tools that the GTM user interface offers.However, one big misgiving in the feature (until now) has been that exporting just a subset of the container version or workspace has been impossible. It’s always the entire container or nothing.

A recent update to Google Tag Manager introduced container notifications.By subscribing to container notifications, your Google Tag Manager login email address can be configured to receive an email for some of the key workflows in Google Tag Manager: containers getting published, and containers being submitted for approval (Tag Manager 360 only), for example.Be sure to check out the official help center article about container notifications.In this article, I’ll walk you through the feature and share a couple of tips on how to make it even more useful!

When you create a Server container in Google Tag Manager, GTM creates an App Engine deployment in the Google Cloud Platform for you.App Engine is a managed serverless platform, which basically means it’s a (set of) virtual machine(s) running in the cloud, with some extra bells and whistles added to make managing it easier.A potentially useful thing that App Engine does is decorate all incoming HTTP requests with some HTTP headers that can be used in the app.

Since the release of Server-side tagging in Google Tag Manager, I’ve jumped at every opportunity to celebrate the tools it provides for improving end-user privacy and data security.One of the biggest benefits is obfuscation-by-default. Since all hits are passed through the server-side proxy, the default view for any third-party tool (such as Google Analytics) is that of the server in the Google Cloud rather than the browser and device with which the user was browsing the site.

Last updated 27 April 2023 with details about preventing FPID access in cookieless scenarios. With Server-side tagging, the developer community has a chance to vastly improve the data collection capabilities of Google’s analytics platforms (Universal Analytics and App+Web). The ability to build our own templates is particularly potent with a Server container.However, it’s not as if Google themselves are just sitting idly by and seeing what the community can come up with.

You can utilize Server-side tagging in Google Tag Manager to build your own custom Universal Analytics proxy.This proxy comes in the shape of a new Client custom template, which takes the incoming /collect requests and sends them to Google Analytics. While doing so, it also returns the _ga cookie in a Set-Cookie header, thus preventing Safari’s Intelligent Tracking Prevention from capping its expiration to just 7 days. You might also be interested in reading what Google’s own solution is for migrating from JavaScript cookies to those set in HTTP headers.

When you use Google Analytics on the web, you are most likely implementing one of analytics.js, the global site tag (gtag.js), or Universal Analytics tags via Google Tag Manager.These libraries all end up doing the same thing: compiling a payload-rich HTTP request to an endpoint at https://www.google-analytics.com.What if you want to have the JavaScript libraries do their job, but instead of sending the data to Google’s servers, you send them to a new, custom endpoint?

Ever since Server-side tagging was publicly announced at SUPERWEEK 2020, Google and the trusted tester community have been hard at work, building something that just might change the landscape of digital analytics for good.Google Tag Manager has now released Server-side tagging into public beta. In this lengthy article, we’ll take a look at what Server-side tagging is, how it should (and should not) be used, and what its implications are on the broader digital analytics community.

In this step-by-step guide, I’ll show you how to build a Lookup Table generator in Google Sheets, utilizing Apps Script and the Google Tag Manager API. The purpose of the Lookup Table generator is to automate the often tedious task of adding many, many rows to a Lookup Table within the Google Tag Manager UI. There are other solutions for this, but none (as far as I know) that uses the Google Tag Manager API.

Hi, I’m Simo Ahava. I’m partner and co-founder at 8-bit-sheep. I’m also co-founder (together with my wife, Mari Ahava) of an online course platform for technical marketers: Simmer.I have also been a Google Developer Expert for Google Analytics and Google Tag Manager since 2014.I hail from Espoo, neighboring Helsinki, the capital of Finland. I have a background in academics (English language and linguistics), in IT, in digital marketing, and in web development.

With the rise of ad and content blockers (think Ghostery and uBlock Origin), as well as browser tracking protections (see www.cookiestatus.com), marketing technology vendors have their work cut out for them. And when I refer to “their work”, I mean they have to proactively identify and exploit any loopholes they can find to keep on collecting their precious data. In this article, I’ll take a look at one such exploit vector, the Canonical Name (CNAME) DNS record, in particular.

Since updating to Google Chrome 83, you might have noticed that Google Tag Manager’s Preview mode no longer works when browsing Chrome in Incognito mode.This is because starting with Chrome 83, third-party cookies are blocked by default in Incognito windows.Google Tag Manager uses third-party cookies to serve browsers in Preview mode with the container draft rather than the live container.There’s a simple workaround to make sure Preview mode continues working for any site you want to browse in Preview mode.

The is an unofficial template for Userpilot. The tag can be used to identify users (with an ID and associated properties), reload Userpilot and re-evaluate page state, track custom events, and trigger specific Userpilot content for the user, regardless of targeting conditions.

Let me start by proclaiming with clarity and sincerity: No, Safari 14 (or any other version of Safari) will not block Google Analytics from loading and running on a website. In the midst of Apple’s yearly Worldwide Developers Conference, the company showcased some of the privacy improvements to the upcoming version of the Safari web browser (version 14). In fact, the biggest revelation was the new Privacy Report, which is designed to elucidate how much the browser is working towards mitigating the damage caused by cross-site trackers.

On New Year’s Eve 2018, I published an article which instructed how to scrape pages of a site and write the results into Google BigQuery. I considered it to be a cool way to build your own web scraper, as it utilized the power and scale of the Google Cloud platform combined with the flexibility of a headless crawler built on top of Puppeteer.In today’s article, I’m revisiting this solution in order to share with you its latest version, which includes a feature that you might find extremely useful when auditing the cookies that are dropped on your site.

You can use this tag to randomly assign users to buckets, and then to store this information in a first-party cookie. This is useful for quick A/B tests and for creating samples or cohorts of your visitors.

This is an unofficial template for the Facebook Customer Chat SDK. You can use it to load the chat SDK and to attach event handlers to the API events.

Recently I published an article on how to set up an impact test for the “flicker effect” omnipresent in client-side A/B-testing tools. Be sure to check out that article first to get some context to what we’re going to be talking about here. In this short follow-up, I’ll show you how to measure the average time of the anti-flicker snippet delaying page visibility, if you choose to deploy the snippet.

This is the official template for the Snowplow Analytics SDK. It supports the full spread of features for the JavaScript tracker, with a few exceptions due to the sandbox of custom templates.

“Flickering” or “Flash Of Original Content” (FOOC) is a phenomenon where there’s a (typically) slight but observable delay in the browser updating the site or element layout if the user is included in a variant group for experimentation. This manifests in the original, unmodified element being rendered in the visible portion of the page before the experiment library updates it with the variant.There are ways to mitigate the flicker:

This template is meant to be used with the Snowplow Analytics tag template. It generates a tracker configuration object for the tag, thus removing the need to configure the tracker manually for every single Snowplow Analytics tag in the container.

When custom templates were released for Google Tag Manager, I updated my workflow for working with GTM. Instead of instinctively rushing to the Custom HTML tag and the Custom JavaScript variable, I started considering whether the custom script that needed to be deployed could be transformed into a custom template first.While publishing numerous templates into the community gallery, I always spent some time over the past 12 months tinkering on an extremely complicated template translation: the Snowplow Analytics JavaScript tracker.

The shadow DOM is a way to add HTML structures to the web page so that they remain isolated from the rest of the document object model (DOM). It’s a popular concept with web components, as it allows for encapsulation of web structures so that they aren’t affected by style declarations of the parent tree, for example. However, being such a “hidden” structure, anything that happens in the shadow DOM is also hidden from Google Tag Manager’s listeners.

One of the most versatile triggers in Google Tag Manager is the Custom Event trigger. As its name indicates, you can use it to fire your tags when an event is pushed into dataLayer.This process is at the heart of GTM’s dataLayer system. And it’s not just custom events. Every single trigger type in Google Tag Manager uses the event key in a dataLayer.push(), which is why you’ll see events like gtm.

This is an unofficial template for the IP Geolocation API. With this API, you can query for geolocation data using the user’s (or a custom) IP address. This information is then written into dataLayer.

With the proliferation of gtag.js implementations, we can see that there’s a small-ish paradigm shift in how to implement Google’s stack of marketing tools.As adding gtag.js snippets to the site code becomes more and more common (to cater to things like early Optimize loading), you might be at a point where you have lots of interesting information stored in the gtag.js queue but no way to access it in your Google Tag Manager tags and variables.

This tag stores the page referrer and URL parameters in a browser cookie. This cookie can be used, for example, on conversion pages or after the user has given consent to attribute the session to the correct campaign. The template also stores the original location of the page to overcome the rogue referral problem on single-page applications.

This is an unofficial template for Qualaroo. You can use this template to initialize the Google Analytics integration, and you can use all of the available Qualaroo JavaScript APIs as well.

One of my passion projects has been to create custom templates for Google Tag Manager’s community template gallery.On this page, I’ll list all the custom templates I’ve created for the gallery, as well as provide a link to each template’s individual documentation page.Do you need help with your template? If you want to commission me for help building your custom template, please contact me at simo (at) simoahava.

I’ve covered the more pervasive issue with tags not firing in Google Tag Manager in my article on the “Still Running” status. However, there’s an additional problem you might face with Google Analytics: tags that show status Failed, and which refuse to send any data to Google Analytics.There are a couple of possible reasons for this, and we’ll explore them in this article. Note that any tag type in Google Tag Manager can signal Failed.

The is an unofficial template for the YouTube Iframe API. A tag created with this template loads the YouTube Iframe API on the page. This is necessary if you want to track interactions in lazy-loaded or dynamically added videos with Google Tag Manager’s native YouTube video trigger.

With so many people working from home or remotely in these turbulent times, it’s time to revisit one of my oldest articles, and discuss the options you have for excluding or segmenting internal traffic in Google Analytics.The traditional method of IP address exclusion is not necessarily the best option anymore, unless all your employees use a specific VPN to connect to the site.In this article, we’ll go through some of the tools you have at your disposal.

With the enforcement of SameSite settings in the latest versions of Google Chrome, it’s become a mad scramble to get cookies working across first-party and third-party contexts. I’ve covered this phenomenon before in my SameSite article, as well as in my guide for setting up cookieless tracking for iframes.Recently, Google Analytics updated its libraries (App+Web, gtag.js, and analytics.js) with a new setting: cookieFlags (analytics.js) or cookie_flags (App+Web and gtag.js).

With iOS and Android containers available for Google Tag Manager, it’s tempting to add GTM as an integration into an existing Firebase setup for your apps. It’s also a fine way to get acquainted with Firebase in the first place, as it has a plethora of features to make application development easier.Furthermore, with the advent of App + Web, there’s even more incentive to integrate your app with Firebase.

One of the hard-and-fast rules in Google Analytics is that once hits have been collected and processed into your data properties, those hits are untouchable. This means that if you mistakenly collect duplicate or incorrect transactions, PII traffic, or referral spam, for example, it’s extremely difficult, if not downright impossible, to purge or change this data in Google Analytics.Another staple of Google Analytics’ strict schema is that displacing hits in time is also very difficult.

Until recently, I had a feature on GTM Tools that polled the user’s Google Tag Manager container(s) for a recently published version. If one was found, a notification was sent to a Slack app, which forwarded it to a workspace and channel of the user’s choice.This was fine, except for the fact that polling the GTM and Slack APIs for dozens upon dozens of containers is a total resource hog, and the only way I can maintain GTM Tools is it doesn’t have API leaks like that.

Updated 25 May 2021: Added information about using this with GA4. As Google Analytics 4 does not have a mechanism to disable cookie storage, only the second solution (send dataLayer events from iframe to the parent) described in this article will work for GA4. Here I am, back with <iframe> and cross-domain tracking. I’ve published a couple of articles before on the topic, with my upgraded solution being the most recent one.

Update 6 April 2020: I updated the template in the gallery to the latest version of the IP Geolocation API SDK, which no longer requires jQuery. Also, the SDK now handles API request caching to browser storage automatically, so the “Enable Session Storage” option was added to the template. Google Analytics had been foreshadowing the deprecation of the Network Domain and Service Provider custom dimensions since late 2019. On February 4, the plug was finally pulled, and both these dimensions started flatlining to (not set) in Google Analytics reports.

One of the most prominent features of Google Tag Manager since the dawn of time (actually, late 2012) is the Custom HTML tag. This little piece of magic lets Google Tag Manager inject an HTML element to the page. Since time immemorial (still late 2012), it’s allowed us to turn Google Tag Manager from a sandboxed prisoner of the native tag templates to a no-holds-barred client-side content management solution. In this article, we’ll discuss how the Custom HTML tag works, and what you might be tempted to use it for.

One of the prime things to use Google Tag Manager for is script injection. Loading a third-party JavaScript library is trivial to do with a Custom HTML tag, and works like a charm.However, using Custom HTML tags for, well, anything, is no longer the preferred way to add custom code to the site. Custom HTML tags are pretty expensive DOM injections, and they can be incredibly dangerous tools (for UX, security, and privacy) in the wrong and/or inexperienced hands.

Update 6 April 2020: I updated the template in the gallery to the latest version of the IP Geolocation API SDK, which no longer requires jQuery. Also, the SDK now handles API request caching to browser storage automatically, so the “Enable Session Storage” option was added to the template. My latest custom tag template tackles a use case I’ve referred to a number of times before, especially in my article on sending weather data to Google Analytics.

Use this template to load hosted libraries from the CDNJS content distribution network.

Update 17 February 2020: Google Tag Manager’s Preview mode cookies have been updated with the necessary flags, so they will not break once SameSite enforcement begins. If you’ve opened the browser console in Google Chrome (since Chrome 76), you might have seen a bunch of warnings in a yellow background related to something called a SameSite cookie attribute that is either missing or incompletely set for cookies set on external domains.

This template can be used to replace the built-in URL variable type. It has additional options, such as building the string from different URL components, and for parsing the URL fragment for key-value parameters as well.

Universal Analytics utilizes two components (by default) to attribute a browser session to a specific campaign: query parameters in the URL and the referrer string.The page URL is sent with every hit to Google Analytics using the Document location field, which also translates to the &dl parameter in the Measurement Protocol.The referrer string is sent with a hit to Google Analytics using the Document referrer field, as long as the referrer hostname does not exactly match that of the current page and the referrer string is not empty.

This template takes an array of objects, and produces a string where the values of one of the given keys in these objects is concatenated into a single string.

Google Tag Manager now lets you add unit tests directly to your custom templates. This is useful, since it allows you to control the code stability of your templates, especially if you’ve decided to share those templates with the public.I recently shared a general guide for how template tests work, but I wanted to expand the topic a little, and share with you two walkthroughs of custom template tests: one for a variable template and one for a tag template.

Use this template to set up a monitoring system for Google Tag Manager. With the monitor, you can collect data about tags that fired (or did not fire) with any given event. This information can be used to proactively fix issues with your tags.

Google Tag Manager introduced the capability to add tests to your Custom Templates. Tests, in this context, refer specifically to unit tests that you write in order to make sure your template code works in a predictable way. Unit tests are also used to drive development, ensuring that you have added contingencies for all the different scenarios that the template, when coupled with user input, might introduce. In this guide, I’ll introduce how the Tests feature works.

In Google Analytics: App + Web, you collect events. One event differs from another event by the name it uses. An event with the name page_view is different from, say, an event with the name file_download.This is all run-of-the-mill stuff. You know this.However, the fundamental change that App + Web introduces, when compared to Universal Analytics, is how event parameters are collected and processed. This gets more complicated than it should be.

There are lots of different readability formulas out there, which seek to provide an index on how readable any given excerpt of text is. Typically, these formulas output a grade-level score, which indicates, roughly, the level of education required to read the text excerpt with ease.Any “quality index” that seeks to reduce the complexity of something as multi-faceted as reading should be subject to scrutiny. This is true for Bounce Rate, this is true for Time On Page, and this is true for a readability score.

I’ve written about outbound link click tracking before. It’s a very solid way to track interactions on the site, as clicking a link that leads away from a site is a signal of … well, something.In Google Tag Manager it’s now extremely easy and efficient to track outbound link clicks, thanks to the introduction of a new configuration in the Auto-Event variable.This article will introduce the new method and show you how you can quickly set it up!

When previewing Custom HTML tags in Google Tag Manager you’ve almost certainly run into a situation where the GTM variable shows up as a weird JavaScript method resembling something like this:google_tag_manager["GTM-ABCD123"].macro(15)And this is when you were expecting it to show the actual, resolved value!It doesn’t help that every now and then the preview mode actually shows to correct value in the preview mode.What’s up with that? Well, there’s a fairly logical explanation to this.

There are thousands upon thousands of bots, crawlers, spiders, and other creepy-crawlies out there doing nothing but crawling through websites and harvesting the content within for whatever purposes they have been fine-tuned to. While Google Analytics provides a bot filtering feature to filter out “spam” and “bot traffic” from views, this is far from comprehensive enough to tackle all instances of bot traffic that might enter the site. You might have noticed bot traffic in your data even if you have bot filtering toggled on.

I’ve thoroughly enjoyed writing short (and sometimes a bit longer) bite-sized tips for my #GTMTips topic. With the advent of Google Analytics: App + Web and particularly the opportunity to access raw data through BigQuery, I thought it was a good time to get started on a new tip topic: #BigQueryTips.For Universal Analytics, getting access to the BigQuery export with Google Analytics 360 has been one of the major selling points for the expensive platform.

This is an unofficial template for the AdService SDK.

This is an unofficial template for the AppNexus pixel.

This is an unofficial template for the Conductrics library. You can use it to load the SDK/API on your site.

Since the introduction of custom templates in May 2019, the community (myself included) has been anxiously waiting for some official solution for curating and distributing templates created by the community.Now, finally, we have it. It’s called the Community Template Gallery! Read Google’s announcement in this blog post. I’m not going to go over the basics in this article, since Google’s own documentation stands fine on its own feet.

Sometimes, in Google Tag Manager’s Debug mode, you’ll see tags appear with the status Still Running, and you’ll (eventually) notice that these tags are not doing what they are supposed to be doing. When you see this message on a tag, it technically means this:The tag failed to signal Google Tag Manager that it is “done”.The technical explanation is, naturally, too simple to be useful. In this article, I’ll explore what “done” means, and how especially Google Analytics tags manifest this behavior.

I’ve enjoyed working with custom templates for Google Tag Manager. A lot. So much so that whenever the need to add some custom code to a container emerges, my first thought is how to turn that into a custom template.Google has been forthcoming in introducing new APIs steadily, and I think the variety of things you can do with template is improving with every new API release.In this article, I’ll show you how to use a simple tag template for distributing your users to groups, based on a random split.

Use this template to build an Enhanced Ecommerce object, compatible with Universal Analytics. This way you do not necessarily have to use the dataLayer at all for populating Ecommerce data into Universal Analytics.

A surprisingly common question in forums and communities seems to be why the built-in Click variables show up as undefined in Google Tag Manager’s Preview mode, even if you click around the site.In this article, I’ll walk you through some of the reasons why this might happen.Tip 104: What to do when Click variables are undefined Here’s the situation: you want to create a Click trigger for your tags, but in order to do so, you’d need to see what values the built-in Click variables (e.

Update 7 October 2020: BigQuery Export can now be configured via the property settings of Google Analytics: App + Web, so you don’t need to follow the steps in this article. Check out Charles Farina’s guide for how to do this. Here’s yet another article inspired by the fairly recent release of Google Analytics: App + Web properties. This new property type surfaces Firebase’s analytics capabilities for websites as well, when before they were restricted to mobile apps only (see my guides for iOS and Android).

A while ago, I published an article on how to build an Android application, and bundle it with Firebase. The purpose of that article, and the one you are reading now, is to slowly introduce the world of mobile app development and Firebase, given the latter is getting more and more traction as Google’s go-to analytics platform.After finishing work on the Android guide, I immediately started working on its counterpart for iOS, and that’s the one you’re reading now.

With the release of Google Analytics: App + Web, Firebase is suddenly all the rage. The new App + Web property can combine data from your website and mobile apps, as long as the latter uses Google Analytics for Firebase, formerly known as Firebase Analytics.In this guide, I’ll walk you through the steps of creating an extremely simple Android application, and we’ll then create a Firebase project, and for good measure add Google Tag Manager to the mix.

It’s been a while since I’ve last written a bona fide Google Tag Manager trick, so here comes. This was inspired by Bart Gibby’s question in Measure Slack.The purpose is to fetch the latest currency exchange rates from the exchangeratesapi.io service, cache them using sessionStorage, and push the results into dataLayer. From dataLayer, they can then be utilized in Custom JavaScript variables and custom variable templates to perform client-side conversions.

Google recently released a new version of Google Analytics called App + Web. Clumsy name aside, this really is for all intents and purposes Google Analytics V2 or Firebase Analytics for the Web. We’re not talking about a charming way to do roll-up reporting between Google Analytics for Firebase and Universal Analytics, nor are we talking about an enhancement to Universal Analytics. No, we’re talking about a new measurement model for web traffic, which has the convenience of being compatible with Google Analytics for Firebase, which you might already have running in your apps.

With Intelligent Tracking Prevention, the Safari browser is on a crusade against cross-site tracking. One of the most obvious and long-standing ways to battle cross-site tracking has been to block third-party cookies in the web browser, and this is exactly what Safari does by default.However, Google Tag Manager’s Preview mode relies on a third-party cookies, so that it can serve you the draft version of the container while serving the regular, live container to your site visitors.

When Custom Templates were released in Google Tag Manager, many of us active in the GTM communities started doing two things: 1) creating our own custom templates, and 2) waiting patiently for Google to release a “gallery” or “library” for distributing these community contributions.While I have full faith in the latter happening some time in the future, I thought it would be fun to create something similar to a library, and then open-sourcing it for the community to help out with or to download locally for their own purposes.

Google Tag Manager is strictly a tag delivery system, and it’s very careful not to collect any analytics data on its own. This is most likely a deliberate choice, because if GTM was to start collecting data, it would introduce additional barriers to adoption.Nevertheless, being a tool that consolidates the design, development, deployment, and testing of all the marketing and analytics pixels, code snippets, and utilities running on a website or a mobile app, lacking the necessary features for auditing and monitoring has always seemed like an oversight.

One of the cool things about Enhanced Ecommerce deployments in Google Tag Manager is that you can use a Custom JavaScript variable to generate the necessary data.There are many reasons to do so, with the biggest one being the flexibility it offers for manipulating the dataLayer object in case quick changes are required on the site, and it would take too long to wait for a new release of the site JavaScript.

One of my pet peeves about Google Analytics has to do with nomenclature. For example, a User isn’t really a user but a browser instance, and Direct traffic isn’t necessarily “direct” at all, but rather just traffic that has no discernible source. But being so invested in content analytics, my biggest gripe has to do with Pageviews.A Pageview in Google Analytics is collected when a hit with the hit type pageview is received successfully by the Google Analytics endpoint.

Last updated 11 September 2020: Added important note about how the custom domain should be mapped with A/AAAA DNS records rather than a CNAME record. Ah, Safari’s Intelligent Tracking Prevention - the gift that keeps on giving. Having almost milked this cow for all it’s worth, I was sure there would be little need to revisit the topic. Maybe, I thought, it would be better to just sit back and watch the world burn.

After the recent release of Custom Templates for Google Tag Manager, my mind has been occupied by very little else. However, I have a nagging feeling that due to how involved the feature set is, there’s still a lot of demystifying that needs to take place before templates are fully embraced by the GTM user base.In this article, I want to show you a concrete example of template creation. It’s going to be much more ambitious than the simple walkthrough I explored in the main guide.

Last updated 12 August 2020: Added details about server-side tagging. As I have finally managed to pick up my jaw from the floor, it’s now time to tell you what’s got me so excited. Google Tag Manager recently released a new feature called Custom Templates. Actually, it’s not fair to call it a feature. It’s a full-blown paradigm shift in how we use Google Tag Manager. It’s a suite of features designed to help brands, companies, and users create and share their own custom JavaScript and HTML setups with ease, while taking care that the code is optimized for delivery in the web browser.

One of Google Tag Manager’s oldest and most reliable features is that it freezes the state of Data Layer variables to the moment when the trigger event occurred. Thus, any tags firing on this trigger (and any variables resolved on this trigger event) will always have access to the same value of each Data Layer variable.However, there are situations where this is not a good thing. One is tag sequencing, and the other is a scenario where you want to run some custom code that should access the latest value of the Data Layer variable at a moment in time after the tag has already fired.

Every now and then I’m fortunate enough to be able to publish guest posts by illustrious people in the analytics and digital marketing industries. This time, I get to work with an old colleague of mine who’s a veritable wizard when it comes to building solutions that make our daily work in the digital industry so much smoother.Erik Grönroos works as an analyst in MarkkinointiAkatemia, a Finnish digital customer acquisition agency.

Some four years ago, Google Tag Manager released a new trigger predicate named matches CSS selector. Slowly but surely, it has evolved into one of the most useful little features in GTM. Even though I’ve written about CSS selectors many times before, I wanted to compile all the relevant information into a single guide. For an external resource, I recommend bookmarking the w3schools.com CSS Selector Reference. But for your day-to-day use of CSS selectors in GTM, this guide will hopefully prove useful.

Trigger Group is the newest trigger type you can add to a tag in Google Tag Manager. It allows you to establish dependencies between multiple triggers, not firing the tag until every trigger in the group has fired at least once. This establishes an interesting new paradigm in Google Tag Manager, because until now it wasn’t possible to create triggers that relied on earlier values of a given key (event in this case).

One of the myths surrounding Google Analytics is that the first hit of a session should always be a pageview. It makes sense - sessions are initialized with a landing page, and thus need a page view to have one. However, in this article I want to show you empirically how this myth is just that - a myth.There is little discernible impact if the first hit of a session is an event, and GA is more than capable of stitching the first event together with the subsequent pageview into a session entity.

In Google Tag Manager, the Custom JavaScript variable is an anonymous function with a return statement. It does not take any parameters, and by default it’s impossible to pass any parameters to it, because the Custom JS variable is simply resolved to whatever value the function returns. If it returns a number, for example, passing a parameter to it would make no sense and would result in a TypeError since the variable resolves to a number, not a function.

Updated 1 October 2019 With ITP 2.3 it looks like Safari is reducing the usefulness of localStorage as well, so using that as an alternative fix to persistence issues should not be considered future-proof. this solution should not be considered future-proof. Updated 12 March 2019 with some minor clarifications.. On 21st February 2019, WebKit announced the release of the latest iteration of Safari’s Intelligent Tracking Prevention (ITP), known as ITP 2.

Updated 1 October 2019 With ITP 2.3 it looks like Safari is reducing the usefulness of localStorage as well, so this solution should not be considered future-proof. The only stable way to persist client-side data at the moment seems to be HTTP cookies. Updated 7 March 2019 - Added some extra caveats to this solution. Also, be sure to read my article on ITP 2.1, which has far more detail on what Intelligent Tracking Prevention is and how to work with it.

The jQuery JavaScript library is by almost any means of counting the most popular JavaScript library used in websites around the world. It’s so influential, in fact, that its evolution is tightly bound to the JavaScript standardization effort itself, and it’s an integral part of the JS Foundation’s efforts to build a community for JavaScript developers. Google Tag Manager, similarly, is the most popular tag management system used in websites, globally.

A recurring question in the Google Tag Manager communities (e.g. product forums) is how to use an Enhanced Ecommerce dataLayer object with the Facebook pixel code? It’s a common question since running a Facebook conversion pixel on a site that also collects data from the store into Google Analytics’ Enhanced Ecommerce reports is probably a very typical scenario. Side note: Since Google+ is about to go the way of the dodo, I’ve created an archive of the entire community which you can browse and make text searches against.

Last updated 9 October 2020: customTask updated to a more stable version. I’m a big fan of Enhanced Ecommerce in Google Analytics. In fact, I think it’s the only valid way to deploy Ecommerce tracking today, especially when using Google Tag Manager. The ability to use a Custom JavaScript variable and the possibility to tackle the full ecommerce funnel are some of the benefits of using Enhanced Ecommerce.

Last updated 9 October 2020: customTask updated to a more stable version. The Custom HTML tag in Google Tag Manager is splendid. It’s your go-to tool when you need to run arbitrary JavaScript on the webpage. Some might even use it to actually add HTML elements to the page, but I’m willing to bet running JavaScript is its most common use.However, there’s a downside to Custom HTML tags, which is only made more apparent on single-page apps which do not clear the full page when transitioning from one state to another.

Thanks to the intrepid detective work of Jørn Reidel and Ahmed Marof, it looks like one of the big hurdles for doing a full migration from using the legacy Google Analytics and Google Tag Manager SDKs to the latest Tag Manager + Firebase SDK is now a non-issue.The issue is, of course, Product-scoped Custom Dimensions or more specifically the lack of support thereof. Until now, I’d been holding against recommending the migration to anyone with Enhanced Ecommerce tracking set up simply because the documentation didn’t mention the possibility of sending these custom definitions to Google Analytics.

Perhaps you didn’t know this, but there’s a really handy demo account for Google Analytics you can use to check out how Google Analytics works in a real business context (the data is from the Google Merchandise Store). However, you can access the account with nothing more than read-only access. This is annoying if you wanted to customize the setup.Worry not, I have a solution for you! Harnessing the awesome power of customTask, you can create a duplicate of the data collected on any website where you can modify the tracking (e.

One of the big problems in Google Analytics’ data model is the immutability of historical data. Once a row of data is written into the data table, it is there practically for good. This is especially annoying in two cases: spam and bogus ecommerce hits. The first is a recognized issue with an open and public data collection protocol, the latter is an annoyance that can explode into full-blown sabotage (you can use the Measurement Protocol to send hundreds of huge transactions to your competitor’s GA property, for example).

In my intense love affair with the Google Cloud Platform, I’ve never felt more inspired to write content and try things out. After starting with a Snowplow Analytics setup guide, and continuing with a Lighthouse audit automation tutorial, I’m going to show you yet another cool thing you can do with GCP. In this guide, I’ll show you how to use an open-source web crawler running in a Google Compute Engine virtual machine (VM) instance to scrape all the internal and external links of a given domain, and write the results into a BigQuery table.

Scope in Google Analytics’ Custom Dimensions refers to how the value in the Custom Dimension is extended to all hits in the same scope.Hit- and product-scoped Custom Dimensions apply to the given hit alone - they are not extended to any other hits in the session or by the same user.Session-scoped Custom Dimensions apply the last value sent during the session to all the hits in that session.

Google Cloud Platform is very, very cool. It’s a fully capable, enterprise-grade, scalable cloud ecosystem which lets even total novices get started with building their first cloud applications. I wrote a long guide for installing Snowplow on the GCP, and you might want to read that if you want to see how you can build your own analytics tool using some nifty open-source modules.But this guide will not be about Snowplow.

If you are enjoying the Element Visibility trigger as much as I am, you’ll be glad to know of a very simple tip that might make your life easier when using Google Tag Manager.The tip is this: If you’ve activated the built-in Click variables, they will be automatically populated with details about the element that caused the Element Visibility trigger to activate!Tip 92: Use Built-in variables to analyze the visible element Yes, it’s confusing they’re still named Click variables, especially since they’re duplicated in the Form variables, and even more so since they can be used with the Element Visibility trigger to identify which element became visibility.

Last updated 18 Jan 2019: Added details about the free tier limitations, and showed how to avoid the Dataflow jobs auto-scaling out of control.I’m (still) a huge fan of Snowplow Analytics. Their open-source, modular approach to DIY analytics pipelines has inspired me two write articles about them, and to host a meetup in Helsinki. In my previous Snowplow with Amazon Web Services guide, I walked you through setting up a Snowplow pipeline using Amazon Web Services.

Speaking in front of an audience can be downright intimidating.As a speaker, you are offering yourself for unsolicited feedback and criticism, you will most likely be ridiculed for the vacuity of your arguments, and you will be berated for your rhetoric or told exactly what you did wrong and why, when all you want is to have a cup of coffee, wind down, and enjoy the rest of the event in a good mood.

If you’re a user of the free version of Google Analytics, and if you have a free Google Analytics property collecting hits exclusively from the Google Analytics Services SDK (Android or iOS), you might have recently received an email that looks like this (emphasis mine): In a nutshell, Google is now starting the process of deprecating the “legacy” Google Analytics for Mobile Apps. This covers all data collection SDKs that do not have the word “Firebase” in them.

UPDATE 4 June 2020: Instead of copying the Custom HTML code from the article, please load it from the GitHub Gist instead. Four years ago, I wrote an article on how to persist GTM’s dataLayer from page to page. Unfortunately, the solution was a bit clumsy, requiring you to give specific commands for the interactions, which made it really unwieldy in the long run. Google Tag Manager still doesn’t offer us a native way to persist the dataLayer array or its internal data model from one page to the other, so I thought it was about time I revisit this idea.

One of the difficulties of working with Google Tag Manager and the dataLayer structure is that GTM doesn’t preserve history of the items collected into its data model. Or, at least, it doesn’t preserve it in a manner that would let us access it.This is typically a very niche problem, but it does surface every now and then. For example, say you wanted to query whether an event with some specific value has already been pushed into dataLayer.

While using the Google Tag Manager user interface around Halloween 2018, you might have noticed a new tab in Google Tag Manager’s Preview mode. The tab is named Errors and shows you the number of exceptions thrown by GTM’s tag templates on the page. In this short #GTMTips post, I’ll quickly walk you through what the tab shows.Tip 90: The Errors Tab In Preview Mode The tab’s name is an apt description of what the tab shows.

Over 5 years ago, I wrote an article titled Track Adjusted Bounce Rate In Universal Analytics. It basically explored a number of different methods to tweak the Bounce Rate metric so that it becomes more meaningful in your Google Analytics reports.Now, writing that article wasn’t necessarily my proudest moment. It’s not because the solution was poor, but rather because I was suggesting it makes sense to tweak a metric. The concept of “adjusted Bounce Rate” sounds like the analyst is fixing a metric to be more beneficial to their cause, rather than fixing the business problem that caused the metric to be poor in the first place.

Google Tag Manager offers us some nice built-in triggers so that we can automatically listen for specific user interactions on the website, reacting to them however we wish, though typically it would be to fire a tag. The tricky thing especially with the click triggers and form submission tracking is that the page has a nasty habit of redirecting you to the link or form target page before letting you see the respective data in Google Tag Manager’s excellent preview mode.

It’s time for a big feature update to my GTM Tools, a free tool for managing your Google Tag Manager containers, tags, triggers, variables, and now: workspaces. In this article, I’ll quickly go over the main features of Workspace mode. Be sure to check out the updated Release Notes & User Guide.Introduction First of all, you can access Workspace mode through the container selection screen, or via the container page:

Enhanced Ecommerce is certainly one of the finest reporting user interface features that Google Analytics has to offer. Enhanced Ecommerce, as the name implies, is a set of dimensions, metrics, and reports, which combine to provide you with a fairly complete view into how users are interacting with your products in your webstore. The main downside of Enhanced Ecommerce is, as with all good things, that it’s complicated to implement.

A very recent addition to Google Tag Manager is the Format Value option in all of GTM’s variables. With Format Value, you can modify the output of the variable with a number of pre-defined transformations.This is extremely handy, because you no longer need to create Custom JavaScript variables whose sole purpose of existence it to change the output of other variables to lowercase, or to change undefined values to fallback strings (e.

**Last updated 18 September 2020: Due to how most browsers now have third-party cookie protections in place, this solution will be very ineffective going forwards. You should instead take a look at a cookieless solution. Some years ago, I wrote a post on how to track cross-domain iframes when using Google Tag Manager and Google Analytics. That solution relied on hitCallback to decorate the iframe, and now that I look back on it, it has its shortcomings.

In Google Analytics, the concept of a session is the key aggregation unit of all the data you work with. It’s so central to all the key metrics you use (Conversion Rate, Bounce Rate, Session Duration, Landing Page), and yet there’s an underlying complexity that I’m pretty certain is unrecognized by many of GA’s users. And yet, since this idea of a session is so focal to GA (to the point of being overbearing), it’s annoying that the browser isn’t privy to any of the sessionization parameters that Google Analytics applies to the hits sent from the browser to its servers.

One of the coolest features of Google Analytics and, as a consequence, Google Tag Manager is customTask. It’s a method you can use to add and execute code as the hit to Google Analytics is being generated.I’ve written A LOT about customTask, and much of the feedback I’ve received has been around the question of how to combine all these different tricks into one customTask script. The problem is, you see, that a tag or hit can only have one customTask script attached to it, so the code within must combine all the different tricks I’ve been writing about over the past months.

You can use the customTask Builder tool to create a customTask script. customTask is a method of the Google Analytics library, which lets you run JavaScript code when the hit request to Google Analytics is being built. Click here to jump directly to the tool. This is very useful for a number of reasons, and I recommend you read customTask - The Guide before doing anything with the tool.

Getting cross-domain tracking right in Google Analytics is difficult. Even if you use Google Tag Manager. There are many known issues when cross-domain tracking iframes, for example.Google Tag Manager implements the cross-domain tracking plugin quite handily via the Universal Analytics tag template, and often the easiest way to track links and form submits is to use the Auto-Link Domains option, as described in this great series of posts on cross-domain tracking by Bounteous.

One of the more difficult concepts in Google Tag Manager is the data model. In essence, the data model is what Google Tag Manager uses to populate the Data Layer variable. You might be tempted to think that it’s the same thing as the dataLayer array, but it’s not.The data model is a representation of the keys and values you push into dataLayer. Whenever you push any key into dataLayer, GTM grabs this key and updates the corresponding key in its data model with the new value, or in the case of objects and arrays merges the old and the new value together.

It’s time for a very simple #GTMTips article (I know, I always write that these are simple tips, but then they escalate into complex behemoths). Today, we’ll cover a nifty trick you can use with the Element Visibility trigger in Google Tag Manager. This tip was inspired by a question from Eugen Potlog in the Google Tag Manager Facebook group.The use case is that you have an Element Visibility trigger firing for a number of elements all sharing the same CSS selector.

Tag sequencing was introdced to Google Tag Manager in late 2015. Its main purpose was to facilitate the sequential firing of tags that have dependencies with each other. Due to the asynchronous nature of third-party libraries like Google Tag Manager, it’s difficult to establish an order of completion with tags that compete for their chance to fire.Tag sequencing changed this, as it allows you to establish setup and cleanup tags - the former firing before the main tag, and the latter after.

One of the great ways to leverage Google Tag Manager in your web analytics tracking is to make use of all the possible custom events that the browser has to offer. One such event is beforeunload. It’s dispatched in the browser when the user is about to unload the page. This means, typically, that the user is about to leave the page after clicking a link, or they are about to exit the browser by either closing the tab or the entire window.

A Content Security Policy (CSP) is something you’ll configure your web server with to add an additional layer of protection, especially from harmful scripts loaded from third-party vendors. Once you have a CSP in place, all resources loaded and executed by the web page need to pass the CSP directives. For Google Tag Manager, this is very relevant. If you have a CSP in place, you will need to modify it so that Google Tag Manager functions properly.

Here we are, reunited with customTask. This time, we’ll put this wonderful mechanism to work for a very, very good cause. One of the lesser known “features” of Google Analytics is that when the payload size (the request body that is actually sent to Google Analytics with each request) goes past a certain limit, specifically 8192 bytes, the hit is aborted without warning. This can come as a surprise, because there’s no indication anywhere in Google Analytics that you are missing hits because of this.

After writing yet another customTask article on how to respect client-side opt-out using Google Analytics and Google Tag Manager, the analytics.js core library was enhanced with a new field that makes it all a lot easier to do. The field, allowAdFeatures, lets you either allow or block the request to DoubleClick that is initiated when Advertising Features have been enabled.In this very short article, I’ll quickly show you what the field does and why it’s useful.

One of my favorite (and most popular) articles in my blog is Improve Data Collection With Four Custom Dimensions. In that article, I show how you can improve the quality and granularity of your Google Analytics data set with just four Custom Dimensions. The reason I chose the four dimensions (Hit Timestamp, Session ID, Client ID, and User ID) is because I firmly believe that they should be in Google Analytics’ standard set of dimensions, but for some inexplicable reason they aren’t.

I’ve spent a considerable amount of time talking and writing about how to improve the granularity of your Google Analytics data, especially when using Google Tag Manager. I’ve also gone on and on and on (and on) about customTask, which makes adding metadata to the Google Analytics hits dispatched from your website a breeze.In this article, I’ll introduce a simple way to add yet another level of detail to your GA hits, using customTask as the method of choice.

When working with the analytics of single-page applications (SPA), there are a number of things to pay attention to. For example, you need to make sure that Google Analytics doesn’t break your session attribution, and that you are not inadvertently inflating your page speed timing metrics. Actually, there are so many “gotchas” when it comes to SPA tracking in tools like Google Analytics that you just can’t get by with a plug-and-play implementation.

Last updated 22 May 2019: Added expiration of currently open tabs. In this article, Jethro Nederhof of Snowflake Analytics fame and I will introduce you to some pretty neat web browser APIs. The purpose of these APIs is to find out more about how the user navigated to the current page, and what’s going on with their browser tabs. There are so many things you can do with this new information.

Here’s a quick tip in response to a query in Twitter by Riccardo Mares. By making a small change to the Google Tag Manager container snippet, you can have the <script> element generated by the snippet notify the page as soon as the Google Tag Manager library has downloaded.What you do with this information is up to you. If you are working directly with the google_tag_manager interface, for example, it might make sense to not act until the interface has been established.

Here’s a hacky #GTMTips tip for you. Have you ever had a Google Tag Manager container, where you’ve been updating your Google Analytics tags over the years? And perhaps these tags (and, today, Google Analytics Settings variables) have been updated with an ever-expanding list of Custom Dimensions? And perhaps this list of Custom Dimensions is sorted willy-nilly, because once you have 50+ rows, it just doesn’t seem like a fun thing to do to go over each row and update them so that they are sorted by Custom Dimension index?

Maybe you knew this, maybe you didn’t, but requests sent from your website (or app) to Google Analytics have a maximum size. Or, more specifically, the payload size (meaning the actual content body of the request) has a maximum.This maximum size of the payload is 8192 bytes. This means, basically, that the entire parameter string sent to Google Analytics servers can be no longer than 8192 characters in length. The thing is, if the payload exceeds this, Google Analytics simply drops the hit.

Hello #wrapper { height: 100%; width: 100%; display: table; } #top { height: 50%; background-color: #5B9BD5; width: 100%; display: table-row; } #bottom { height: 50%; background-color: #fff; width: 100%; display: table-row; } #greeting { color: #fff; font-family: Lobster,sans-serif; font-size: 2em; vertical-align: bottom; text-align: center; display: table-cell; padding: 10px; } #subscribe { vertical-align: top; text-align: center; display: table-cell; padding-top: 20px; } #email-field { width: 700px; height: 50px; color: #838383; font-size: 3em; padding: 5px; border: 2px dotted #ddd; font-family: sans-serif; } #subscribe-button { background-color: #f08406; border: 1px solid #ad5d15; -webkit-box-shadow: inset 0px 1px 0px rgba(255,255,255,0.

When using the All Elements trigger in Google Tag Manager, it’s easy to overlook the fact that it captures all clicks on the page. It’s also brutally accurate - it captures clicks on the exact element that was below the mouse button when a click happened. This means that when working with the All Elements trigger, you need to be more careful when identifying the correct element you actually want to track clicks on.

A while ago, I published a #GTMTips article, where I showed how you can add HTML elements to the page programmatically using Google Tag Manager. This is relevant because GTM’s validators prevent you from adding custom parameters to HTML elements that are injected directly via the Custom HTML tag. To circumvent this validation, you need to create the element programmatically, before appending it to the document.A while ago, Matteo Gamba asked me a question related to the Facebook Customer Chat Plugin.

Agile analytics isn’t a novel concept in any shape or form. Things like feedback loops and process-oriented development seem to integrate flawlessly into the analytics paradigm, at least on paper. Heck, there’s even the Build-Measure-Learn framework for continuous development. It would be difficult to argue that analytics doesn’t have a role in something with measure in the name!However, past three years of working at Reaktor, one of the world’s top agile technology houses, have introduced me to a whole new set of problems with integrating an “analytics mindset” into an agile workflow, or an “agile mindset” into the analytics process.

Last updated 7 December 2021: Added a new chapter to highlight the fact that Zone containers have no access to prior state on the page before they were loaded. Google Tag Manager supports loading multiple containers on the same page. It’s useful if you have multiple companies or organizations working on the same site, but for one reason or another (e.g. governance) you want to restrict access to your main container.

When you use the dataLayer.push() command on a page with a Google Tag Manager container, you pass information to GTM’s internal data model and potentially fire tags (if the push() contained an event key). You can also add the eventCallback key to these pushes. The value of this key should be a function, and this function is then executed once the container finishes processing any tags that might have fired on that dataLayer.

Last updated 9 March 2018 with some new tips.The Scroll Depth trigger in Google Tag Manager has a lot going for it. Tracking how far users scroll down a given page has long since been recognized as an important cog in the engagement tracking machine, and there have been really great solutions for implementing scroll depth tracking for web analytics over the years.With Google Tag Manager’s native Scroll Depth trigger, it’s tempting to think we now have a be-all end-all solution that covers all the bases.

One of the annoying quirks of Google Tag Manager is that it strips out any non-standard HTML attributes from elements you add to Custom HTML tags. I’m using “non-standard” as a qualifier here, because I don’t have an exhaustive list of attributes that are ignored. But at least data attributes (e.g. data-id) and attributes with custom names (e.g. aria-labelledby) are either stripped out upon injection, or GTM might actually prevent you from even saving the container if the Custom HTML tag has elements with these attributes.

This is one of those #GTMTips posts that I was certain I’d already written. So it came as a mild surprise when I realized I’d never tackled this aspect of Google Tag Manager.It’s a short and sweet tip again. Today we’ll learn how to check if a variable is undefined using Google Tag Manager.Tip 73: Check for undefined variable values If a variable is undefined, it means that a variable with the given name does not currently have any valid value in memory.

Last updated 4 September 2018If you have been reading my blog articles over the past year, you might have noticed a disturbing trend. I’ve published 9 articles on customTask since the API was released. It might not sound like much, but I can’t think of a single feature in Google Analytics or Google Tag Manager that has so completely convinced me of its usefulness in such a short time.

When the Google Analytics Settings variable was introduced in May 2017, it resulted in a significant change in the Google Analytics tag user interface in Google Tag Manager. The default UI for editing a tag was stripped down of all GA-specific settings, and the new Google Analytics Settings drop-down was the replacement.Unfortunately, the bulk of Google Tag Manager articles online (including those on this blog) still refer to the old interface in screenshots and instructions.

Google Tag Manager should be relatively easy to implement. Just paste the container snippet to the <head> of the page and you’re good to go! However, at some point you’ll want to configure the dataLayer structure, too (read more about dataLayer here). There are two ways to do it: the right way and the wrong way.In this article, we’ll see what happens if you do it the wrong way, how to identify the issue, and how to fix it.

A recent guide of mine introduced the Google Analytics adapter in Snowplow. The idea was that you can duplicate the Google Analytics requests sent via Google Tag Manager and dispatch them to your Snowplow analytics pipeline, too. The pipeline then takes care of these duplicated requests, using the new adapter to automatically align the hits with their corresponding data tables, ready for data modeling and analysis.While testing the new adapter, I implemented a Snowplow pipeline from scratch for parsing data from my own website.

I’m back with another customTask tip, but this time I’m exploring some new territory. Snowplow just introduced their latest version update, which included (among other things) an adapter for processing Google Analytics payloads. Never heard of Snowplow? It’s a collection of open-source libraries designed to let you build your own analytics pipeline, all the way from data collection, through ETL (extract, transform, load), using custom enrichments and JSON schemas, and finally into your own data warehouse, where you can then analyze the data using whatever tools you find preferable.

First of all, check out this article for an overview of how custom event listeners work in Google Tag Manager. The reason I’m writing this #GTMTips article is that I want to upgrade the solution slightly, and I want to bring it back into the spotlight. Why? Because it’s still one of the most effective ways to customize your Google Tag Manager implementation.A custom event listener is a handler you write with JavaScript.

As the year changed to 2018, I decided to abandon WordPress, which I had been using for over 12 years as my content management system of choice. I had many reasons to do so, but the biggest motivators were the opportunity to try something new and to abandon the bloat and clutter of WordPress for a more simple, more elegant order of things. Spurred on by another adopter, Mark Edmondson, I decided to give Hugo a go (pun intended).

Over the past few weeks, I’ve been coding like crazy. The three biggest outcomes of this frenzy have been this new blog design (switched finally away from WordPress and took the plunge back into the world static sites using Hugo), a new Google Sheets add-on for managing Google Tag Manager containers and assets, and a Slack integration in GTM Tools. In this article, I’ll quickly introduce the last two, as I’m writing a separate article about the site redesign.

A while ago I posted a #GTMTips post where I detailed the steps you can take to opt-out of all Google Analytics tracking and the DoubleClick redirects that often follow. It was a fun exercise, but because it relies on preventing requests on a tag-by-tag basis (using the ubiquituous customTask), it can be a chore to handle in large containers.In this article, we’ll continue with the theme of opting out from Google Analytics tracking by leveraging a solution provided by the tool itself.

10 Oct 2024: Digital Analytics Summit, Amsterdam 24 Oct 2024: SMX London 9 Nov 2024: MeasureCamp Stockholm I enjoy presenting at conferences and meetups, and I have a track record of hundreds of talks since 2013, comprising keynotes, conference presentations, workshops, seminars, and public trainings. Audience sizes have varied between 3 and 2,000.My favorite topics revolve around web analytics development and analytics customization, but I’m more than happy to talk about integrating analytics into organizations, knowledge transfer, improving technical skills, digital marketing, and content creation.

The GTM Tools by Simo Ahava is a Google Sheets add-on. It lets you manage and update your Google Tag Manager containers, tags, triggers, and variables. In this first iteration, the tools feature a Documentation builder, which lets you automatically generate documentation for the latest version of your Google Tag Manager container, tags, triggers, and variables. In addition to this, the toolset features a Push changes to Notes functionality, which lets you automatically mass update the Notes field across your tags, triggers, and variables.

Update 5 March 2019 due to GTM not supporting negative lookbehinds any more. Google Tag Manager makes it fairly easy to do cross-domain tracking. Basically, you list the hostnames you want to automatically decorate with linker parameters in the Auto-Link Domains field of your Page View tag, and that takes care of decorating the URLs with the necessary parameter. It’s dead easy, even if there are a bunch of traps you need to watch out for (see my post on troubleshooting cross-domain tracking issues).

When Google released gtag.js, the new, global tracking library designed to (eventually) replace analytics.js, many Universal Analytics practitioners and users were confused (see e.g. Jeff’s great overview here). It seemed like gtag.js wasn’t really solving any immediate problem, since analytics.js had done a bang-up job with Universal Analytics tracking for all these years. However, gtag’s modus operandi is the ability to leverage the same semantic information (distributed across dataLayer!) across a number of Google products, starting with GA and AdWords.

One of the challenges in working with Google Tag Manager (or any JavaScript-based platform for that matter) is what to do with race conditions. A race condition emerges when you have two resources competing for execution in the browser, and there is a degree of unpredictability to which “wins” the race.A prime example is working with jQuery. It’s one of the most popular JavaScript libraries out there, and websites utilize it for a multitude of things, many useful for Google Tag Manager, too.

Simo Ahava is a recognized expert on customizing web analytics and tag management solutions to improve the entire “life cycle” of data collection, processing, and reporting. His main areas of expertise lie with Google Analytics and Google Tag Manager, and Google has appointed him as a Google Developer Expert in these fields. He is especially interested in communication structures within organizations, as he firmly believes that communication breakdowns are the underlying cause to practically all data-related problems.

I really like Google Optimize. It has a fairly intuitive UI, setting up experiments is easy, and there’s integrations for both Google Tag Manager and Google Analytics built into the system. It’s still a JavaScript-based, client-side A/B-testing tool, so problems with flicker and asynchronous loading are ever-present (though this is somewhat mitigated by the page-hiding snippet).One issue with the Google Analytics integration is the difficulty of creating segments for sessions where the users were actively participating in the experiment.

With GDPR looming around the corner, it’s time to explore the options you have at your disposal for respecting the new, stricter regulations for tracking users and for collecting data about their visits to your website. UPDATE 20 June 2018: Google has released the allowAdFeatures field which renders the solution below redundant (at least for the displayFeaturesTask part of it). Please refer to this article for more details on how to conditionally block the advertising hit to DoubleClick.

Scroll depth tracking in web analytics is one of those things you simply must do, especially if you have a content-heavy site. Tracking scroll depth not only gives you an indication of how much users are digesting your content, but it also lets you turn meaningless metrics such as Bounce Rate into something far more useful.If you’ve already been tracking scroll depth in Google Tag Manager, you’ve probably been using either Rob Flaherty’s brilliant Scroll Depth jQuery plugin, or Bounteous’ equally ingenious Scroll Tracking recipe.

Holy visibility, Batman! Visibility is a seriously undervalued aspect of web analytics tracking. Too often, we fall into the trap of thinking that “Page Views” actually have something to do with “viewing” a page. Or that tracking scrolling to 25%, 50%, or 75% of vastly different pages makes sense on the aggregate level. So you will be very pleased to know that the Google Tag Manager team (who have been on FIRE recently), have just published the Element Visibility trigger.

5 years ago, on 1st October 2012, this lovely video popped up in Google’s Analytics Blog:It was accompanied by a blog post, which contained a brief look into many of Google Tag Manager’s key features, some of which are still relevant today.Google Tag Manager is a free tool that consolidates your website tags with a single snippet of code and lets you manage everything from a web interface. You can add and update your own tags, with just a few clicks, whenever you want, without bugging the IT folks or rewriting site code.

Universal Analytics can collect Page Timing data from users that load your pages. This data is populated in to the Behavior -> Site Speed -> Page Timings report, and it’s a very useful feature for optimizing your website. However, there’s a murky underside to this generous feature. The way Page Timings collection works is that when Pageview hits are sent from the site, a sample of these (1% by default) are automatically followed by a timing hit which includes page performance data grabbed from the Navigation Timing API.

Ever since the Lookup Table variable was introduced in Google Tag Manager, users have been craving for more. The Lookup Table does exactly what it promises: lookups. These are exact match operations, which are extremely inexpensive to perform, because they can only have a binary result: either the match exists in the data store being queried or it doesn’t. This performance stays constant even if the data store being queried increases in size.

There’s a fabled, mythical beast that prowls the jungles of digital marketing. They have no issues with running and analyzing crawler data, offering suggestions for server-side redirects, building remarketing audiences, implementing tag management solutions, speaking of Data Layers, copy-pasting code from Stack Overflow, configuring bid managers, and speaking at conferences presenting on all the aforementioned activities. However, for some reason, they still claim that they are “non-technical”, or “just marketers”.

Last updated 20 April 2020: Clarified how lazy-loaded videos can be tracked with this trigger. Let’s cut straight to the chase. Google Tag Manager has just released the YouTube Video trigger, which gives you native support for YouTube video tracking. And it’s great! Even though we’ve been more than satisfied with the excellent tracking scripts provided by e.g. Cardinal Path and Bounteous (with a small modification from yours truly), this is a no-brainer for native support in Google Tag Manager.

Sending personally identifiable information (PII) to Google Analytics is one of the things you should really avoid doing. For one, it’s against the terms of service of the platform, but also you will most likely be in violation of national, federal, or EU legislation drafted to protect the privacy of individuals online.In this #GTMTips post, I’ll show you a way to make sure that any tags you configure this solution with will not contain strings that might be construed as PII.

The steady increase in mobile use over the last years has introduced some new challenges for web analytics. It’s not just about mismatches in the tracking model (the concept of sessions is even more absurd for apps than it is for desktop browsing), but about something more fundamental, more basic. Think about it: if a visitor visits the website using a mobile device, there’s a significant chance of them losing internet connectivity and going unintentionally offline.

If you open the Google Tag Manager user interface and browser your tags, triggers, and variables, you might notice that the UI now has two new features: Pagination, where only 50 results are shown per page A quick search / filter bar at the top of each list, which lets you narrow the list down to results that match your query Pagination might be a nuisance in large containers, but it was implemented to improve performance.

More often than not, much of what we do in web analytics can be automated. This applies especially to implementations, audits, configurations, and reporting. So when I’m faced with a menial, manual task that might take hours for me to complete if done by hand, I always look at what could be done with some scripting and API work. I want to introduce a couple of Google Sheets add-ons I’ve written and released to the public.

The Custom Dimension Manager For Google Analytics is a Google Sheets add-on. It lets you update Custom Dimensions in any given Google Analytics property en masse. When updating, new dimensions are created automatically with values from a source data sheet (or using a default value if no value is specified), and for existing dimensions you have the choice to update or skip. The add-on is completely free to use.

The Google Analytics Validator is a Google Sheets add-on. It lets you build a spreadsheet of all the accounts, properties, and views you have access to in Google Analytics. Then, you can select any number of these properties to populate a second sheet, where each Custom Dimension configured in the property is displayed with its name, scope, and active status. Finally, you can poll for the last 7 days data for any selected property/view to see if the Custom Dimension has collected any hits.

Here are the two Chrome Extensions I’ve written. GTM Sonar - Debug your on-site JavaScript to see if it’s compatible with the event listeners Google Tag Manager leverages Internalize for Google Analytics - Send a Custom Dimension hit at the click of a button. This tool is intended to annotate traffic in a certain way, letting you filter it out or process it in any way you choose

GTM Tools are utilities created for managing Google Tag Manager containers. The main features are: Clone containers from one account to another (or within the same account) Visualize containers Inspect containers, and add individual assets (Tags, Triggers, Variables) to a “Shopping cart” Clone Shopping cart contents as a new container in a GTM account Save Shopping cart contents into an asset library for future use

Tracking what a user selects in a drop-down (or select) list/menu can be very useful. This is particularly the case when the selection immediately does something, such as initiate a download or navigate the user to another page. But even if there is no immediate action, it’s still interesting to know what selections users might be doing, if only to uncover yet another piece of the engagement puzzle. Here’s the Google Tag Manager way to do it!

Facebook’s pixel has an attribute named content_ids (required for Dynamic Ads), which requires an Array of content IDs as its value. It’s very possible you’re running this pixel on a site which already has Enhanced Ecommerce for Universal Analytics implemented, and now you want to use the same Enhanced Ecommerce data that your developers have already made available in this Facebook pixel.Or perhaps you want to concatenate a list of strings, such as article tags (['culture', 'politics']), and send it as a comma-separated string to Google Analytics ('culture,politics').

Here we are again, revisiting an old theme. When using Google Tag Manager, we often want to send the contents of the same tag to multiple Universal Analytics properties. With on-page GA, this used to be quite simple, as all you had to do was create a new tracker and then just remember to run the ga('trackerName.send'...) commands to all the trackers (or you could use my duplicator plugin). With GTM, your options are more limited, since Google Tag Manager abstracts the tracker object, giving you far fewer tools to work with.

One of the things I’ve recommended from the get-go is to always send the Client ID to Google Analytics with your users’ hits. This is very useful for adding a level of granularity to your tracking. At first, I recommended using an Event tag to do this. Then I modified my approach a little so that you could send it with your initial Page View (thus not inflating your hit counts).

Let’s face it - most of us use Google Tag Manager for one main purpose: to deploy and configure Google Analytics tracking on a website. I’d wager that once you start using GTM, you won’t be implementing Universal Analytics the old-fashioned way, with on-page code, any more. But running Universal Analytics tags through GTM isn’t yet a perfect workflow. We’re still missing things like proper plugin support and the option to properly differentiate between the tracker and the hit - both of which are easy to do with an on-page implementation.

This is, by no means, a novel topic in this blog. I’ve covered Google Tag Manager’s event tracking and triggers numerous times before (see below). Auto-Event Tracking In GTM 2.0 #GTMtips: Track Outbound Links In GTM V2 #GTMtips: Fix Problems With GTM Listeners Trigger Guide For Google Tag Manager However, based on the number of queries we still see in the Google Tag Manager Product Forums about event tracking, I believe one particular aspect of GTM’s triggers invites revisiting.

Apart from the unlimited number of workspaces, the 360 Suite version of Google Tag Manager didn’t have any differentiation from the free version feature-wise, until today. GTM just introduced an approval workflow, which allows you to exercise some additional control over what changes are pushed to the live site, or created into versions.Note that this update also introduced a small change in the regular GTM UI - mainly, the menu that used to have “Create Version”, “Publish” and “Preview” is now changed into a dual button layout with just Preview and Submit as the options.

Autocomplete search is a tricky thing to track. The underlying logic is that when the user starts feeding characters into a search form, the search suggests results based on a limited input. If the user is not satisfied with the results, they can continue adding characters to the search, thus increasing the accuracy. Often there’s also the option to revert to a regular search with what they’ve already written. Tracking this logic in tools like Google Analytics is difficult, because there’s really no way to know if the search was successful.

In this #GTMTips article, we’ll take a look at user permissions and access control levels that Google Tag Manager lets you set today. Doing access control right from a user interface AND user experience perspective is really difficult, and GTM is no exception. Nevertheless, there are several levels of user control that you can modify from account and container settings, and it’s useful to familiarize with these so that managing a big, sprawling account hierarchy would be just a bit easier.

With the release of the latest Google Tag Manager API version, it’s time to release the new version of GTM Tools. Most of the changes have been done under the hood, with the entire codebase refactored for improved stability.I released the first toolset in October 2014, and quickly released an updated UI a few months later. Aside from a few bug fixes and stability improvements, the tools have remained largely unchanged since then.

Google Tag Manager has a very nifty programmatic API that lets you do almost anything that’s also possible within the GTM UI. I’ve used the API a lot, most notably for my GTM Tools, which might be getting a new release soon, too!The API was recently updated to its second release version (V2), and in this article I want to go over the additions, removals, and changes that the new version introduced.

To be fair, this tip isn’t just for Google Tag Manager but for regular old on-page Google Analytics as well. It’s one of those little things that’s corroding your data quality without you ever realizing it. Namely, this tip is about how to handle cross-domain tracking in situations where you are sending data to multiple Google Analytics properties on the same page.It’s a very typical scenario - you have a “local” property, which tracks only the traffic of the current site, and then a “rollup” property, where you send data from all your organization’s websites.

I’ve always been proud to avoid the typical headline clickbait of “Ultimate guide to pigeon care”, “All you need to know about the Great Vowel Shift”, “Did you know that you’ve been smoking peyote wrong your whole life?”. I’m ready to make an exception now by adding a BIG WHOPPING NUMBER to the title. You see, the amount of knowledge one can accumulate about anything they do on a daily basis is mind-blowing.

A couple of years ago I wrote an article on tracking interactions with the SoundCloud widget via Google Tag Manager. When a platform provides a JavaScript embed API, it’s surprisingly easy to track interactions with the player. You’ve seen this with YouTube, with SoundCloud, with JWPlayer, and now you’ll see how to do this with the Mixcloud player. If you don’t know what Mixcloud is, well it’s a hugely popular streaming service for DJs, podcasts, radio shows, and other published radio media.

The beauty of #GTMTips, at least how I’ve envisioned them, is that they can be really simple or crazy complex. The important thing is that the idea is conveyed clearly enough. That’s why so many of these tips have originated from discussions in our Google Tag Manager Google+ community, the Product Forums, and in private email correspondence with people asking for help. Today’s tip, for example, originated from a back-and-forth with Süleyman Okan, so thank you for the inspiration!

Last updated 24 August 2022: The instructions in this article are no longer that useful, as you can simply use the native JavaScript Element.closest(selector) method instead of the {{Find Closest}} trick described in this article. Browser support for closest has thankfully improved a great deal since this article was originally written. Google Tag Manager provides us with a bunch of handy triggers, designed to make capturing user interactions on the website much easier.

One of the biggest fears I have as a Google Tag Manager user is a broken release of the website (or app) on which I have deployed GTM. Far too often, lack of proper communication practices within an organization lead to a release being pushed out without thoroughly testing how this release impacts any existing tracking solutions. Luckily there are ways to mitigate this. The most significant and impactful precautions you can take are all about process:

I recently published a #GTMTips guide called 10 Useful CSS Selectors, and it was very well received. Inspired by the feedback, here’s the next instalment. This time, we’re going over some useful JavaScript tips and tricks that you can use to make your Google Tag Manager deployment even more efficient. I’ve written a lot about JavaScript in this blog, and I intend to keep on doing so in the future. As always, if JavaScript is somewhat of a mystery to you, I strongly recommend you take the Codecademy (free) course on JS, and take a look at the other available web technology tracks while you’re there!

Without a doubt, the possibility to leverage CSS selectors in Google Tag Manager’s trigger conditions is one of the most useful features of the platform. It gives you an amazing amount of flexibility, especially when combined with GTM’s click and form triggers.Essentially, CSS selectors let you test an HTML Element against a selector string. This check verifies that the element matches the given selector. In practice, this would mean that when you use the click or form trigger, you can check if the Click Element or Form Element built-in variables match a specific selector, allowing you to confirm that the action happened on the correct element.

A while ago, the Google Tag Manager team published one of my favorite feature releases in the history of GTM: Workspaces. I was so thrilled by this release that I went ahead and published a guide on how to implement and leverage this new feature.Workspaces is a very comprehensive feature in Google Tag Manager. This is because it changed the entire underlying data model. We no longer work directly with a single container draft.

READ THIS (26 Aug 2019)!! Unfortunately, the update I made in 2016 contained code that was incomplete and broken. I nevert noticed this until it was pointed out to me almost three years later. At this point, I don’t have a working backup of the solution, so unless some internet archive / cache service manages to surface the code, this article is basically lost. UPDATE 20 December 2016: I made some fixes to the solution - be sure to grab the latest code snippet from below!

I took my Spam Filter Insertion Tool down since it’s very ineffective for tackling referral spam in Google Analytics. There are far better ways to combat spam.You can still download the source in the GitHub repository if you want to build the tool yourself.

This article is a collaboration between Simo and Dan Wilkerson. Dan’s one of the smartest analytics developers out there, and he’s already contributed a great #GTMTips guest post. It’s great to have him back here sharing his insight on working with Accelerated Mobile Pages (AMP).So, we’re back on AMP! Simo wrote a long, sprawling AMP for Google Tag Manager guide a while ago, and Dan has also contributed to the space with his guide for AMP and Google Analytics.

Google Tag Manager recently published support for Accelerated Mobile Pages (AMP). This support comes in the form of a new Container type in Google Tag Manager. When you create an AMP container in GTM, you are actually setting up an external configuration for AMP, which leverages AMP’s own analytics module. As befits Google Tag Manager, creating the configuration is done in the familiar Google Tag Manager user interface, and you have (almost) all the tools of regular Google Tag Manager at your disposal.

Single-page sites (or single-page apps) typically have just one page load. When navigating the site, subsequent content is either uncovered from the DOM, where it’s been in a hidden state, or loaded from the server using HTTP requests that do not invoke a new page refresh. This behavior, however, has some implications for Google Analytics tracking, especially when configured via Google Tag Manager.The crux of the problem is this: When you create a Google Analytics tracker, the URL of the page (without a possible #hash) from when the tracker was created is sent as the value of the Document Location field with every hit that uses this tracker.

Google Analytics’ Site Speed reports are pretty darn great. They report automatically on various milestones in the process the browser undertakes when rendering content. These reports leverage the Navigation Timing API of the web browser, and they are (typically) collected on the first Page View hit of a page.And this is all fine. As I said, it’s a great feature of Google Analytics, and lends itself handily to spotting issues in the quite complex client-server negotiation that goes on when your web browser requests content from the web server.

What better way to celebrate the 50th #GTMTips article than, well, a really useful Google Tag Manager tip?! This tip is so useful and simple; it encapsulates everything that I had in mind when starting this series. The tip is about restricting scope of Custom HTML Tags. This is an important concept, because it’s possible that you’re stuffing your page’s global JavaScript namespace with all sorts of junk, and thus inadvertently causing conflicts.

This is a guest post by Stephen Harris from Seer Interactive . He was kind enough to share his awesome solution in this blog, so I’m very grateful indeed for his contribution.If Google Tag Manager is loaded as the primary instrument for tracking on a webpage (as it should be), then all webpage tracking could and should be configurable via GTM. But we don’t always control the circumstances, and it’s not uncommon to face hardcoded Google Analytics tracking outside of GTM.

Google Tag Manager can be quite the hierarchical mess. You have accounts which comprise containers. Containers are split into container versions, and you use workspaces to create new versions. Phew! Trying to keep tabs on all the activity within these layers can be quite the chore.In this #GTMTips article, I’ll do a quick walkthrough of (almost) all the places where you can review changes made in your Google Tag Manager account and container.

I’ve already written extensively about JavaScript in web analytics implementation. Suffice to say, understanding at least the basics is absolutely necessary to survive in the technical medium of the web browser. This article expands on a conference talk I gave at MeasureCamp IX, London a short while ago. I’ve always been quite single-minded about the importance of JavaScript in web analytics development, and it was a pleasure for me to get some of that off my chest.

It’s been a crazy week. Just crazy. Not only did Google Tag Manager introduce Workspaces, arguably one of its most important releases ever for GTM, but they also revamped the user interface! So very big changes have been underfoot, and I’m so happy to be writing about them, because in my completely biased opinion these changes are amazing and well worth the long wait.In this article, I want to quickly walk you through what I think are the most meaningful changes in the interface.

Well, well, well. Welcome to the Enterprise Game, Google Tag Manager! You know, if you took a look at all the feature requests and complaints that pass through the Google+ community or the Product Forums, you’d notice that a large portion of them revolve around lack of multi-user and multi-team support in the tool. Well GTM has taken a gigantic leap forward to soothe these concerns, with the release of its latest feature: WORKSPACES.

Cross-domain tracking, in Google Analytics, is the process of passing information stored in browser cookies from one domain to another. Due to web browsers’ same-origin policy, a browser cookie is only available to the domain it is written on and all its subdomains (by default). Since Google Analytics uses cookies to persist the Client ID, once the user moves from domain to domain it’s important to somehow pass this Client ID, too.

Last updated 2 March 2018.Every now and then you might be urged to run Google Tag Manager and/or Google Analytics locally, meaning without the benefit of a web server serving your files. In other words, you’re loading an HTML file from your computer in the web browser. You can identify a locally run file by the file:/// protocol in the address bar. Now, deploying Google Tag Manager onto that file with the hopes of running Google Analytics requests locally isn’t quite simple.

There are times when I’m disappointed with Google’s developer documentation, especially for Google Tag Manager. Most of the time they get it right, and I’d say around 80% of questions being thrown around the forums can be answered just by reading through the documentation. But there are some cases where the documentation is misleading or even downright dangerous. One of these cases is Enhanced Ecommerce.This isn’t going to be a thorough critique of said documentation, but the tip in this post has to do with one of the examples that the documentation gives for measuring Product Clicks.

Enhanced Ecommerce is a very useful set of reports in Google Analytics. They extend the standard Ecommerce funnel, which measures only purchases, and allow you to observe products from the very first impression, through various interactions, all the way to the purchase and even beyond, if the user wanted a refund. Google has some solid documentation on how to implement and interpret Enhanced Ecommerce, but if there’s one area that would deserve more illumination, it’s attribution.

Have you created a Chrome Extension, and now you’re dying to find out how users are interacting with it? Perhaps you want to see what features are (not) being utilized, or perhaps you’re just interested in knowing if people are actually using it.In this article, I’ll show you how to configure Google Tag Manager, so that it works in the restricted sandbox of the Chrome Extension. You’ll need to make some tweaks, but it’s still perfectly doable.

I have very little against Google Analytics’ default dashboards. The reason I shy away from them is because they lack the type of customization I’ve come to expect from a dashboarding tool. On top of that, they only let you look at GA data, and I learned early on in my career that focusing on just one vertical is one of the cardinal sins you can make as an analyst.

Google Tag Manager is a great tool. Yeah, you came all the way to this article to read that truism. It also performs really well, loading at a sweet, swift pace even on a slow connection, thanks to pretty decent response times from Google servers. On top of that, the library itself loads asynchronously, meaning the container download doesn’t interrupt the browser as it tries to make sense of your messy HTML.

First of all, I’m sorry about the title. I should really stop throwing the word “simple” around, since people always tell me that the stuff I claim to be easy and straightforward is rarely so. But since this is my blog, I reserve the right to use whatever stupid and misleading terminology I want. I maintain that what follows IS quite simple, especially when considering the amount of complexity it reduces in your Universal Analytics setup.

This article is a guest article by someone from the analytics community I really look up to. Dan Wilkerson is an analytics developer at Bounteous, a company I hold in high esteem. Dan is one of the smartest technical analytics experts out there, and a large bulk of the awesome scripts and hacks that Bounteous produces (almost on a daily basis) have been orchestrated by him. So I’m very pleased to give the floor to Dan, so that he can tell you all about using the pesky document.

Google Tag Manager has a Trigger type which fires after a certain duration of time has passed on the web page: the Timer Trigger. The most common uses for the Timer Trigger seem to be either to send an event to Google Analytics after X seconds of dwell time (to kill the Bounce), or to defer a Tag from firing until some asynchronous request has completed with certainty.In the previous version of Google Tag Manager, the Timer was a separate listener Tag, which meant that you could start a timer based on a user interaction such as a click.

Quite a while ago, I wrote an article on what I considered (then) to be my favorite Google Tag Manager resources. Many of them are still very valid, but I still wanted to write a follow-up. Times have changed, and GTM is very different from what it was two years ago when I wrote the post.So in this article, I want to divert your attention to 10 blogs, 10 articles, and 10 people - all which are and/or share excellent Google Tag Manager content on a periodic basis.

I started writing articles in May, 2013. The first couple of articles written during the first months of this blog’s life were not very good. Things picked up when I started focusing only on Google Analytics and Google Tag Manager articles.The following statistics are powered by Google Data Studio.

Back back to the friggin’ basics. Almost two years ago, I wrote a two-parter on how to have fun with Google Tag Manager: Part 1, and Part 2. The first part had a nice exercise for tracking JavaScript Errors as Google Analytics Events, using the recently published “JavaScript Error Listener” Tag.Well, that was in GTM V1. Now we’ve been smoothly sailing with the wonderful new interface for well over a year, and it’s time to update some of these nifty tricks.

I’m currently at SMX München, which is still one of my favorite conferences in Europe. The quality of the talks is superb, and the organization is just perfect. So today, after my talk (joint session with the awesome Dave Sottimano), I was listening to the inimitable Mike King give an excellent presentation together with Ari Nahmani on technical skill prerequisites for all digital marketers today. Needless to say, I strongly agree with their view that digital marketing has always been a technical discipline, and the web is getting more and more complex each day that passes.

A couple of days ago, I wrote an article on tracking content engagement. Even though the solution itself works, and it’s a really neat trick if I can say so myself, it has its problems.After all the glory I showered on User Timings in Google Analytics, they have one serious flaw: they cap at 10,000 samples per day. What a ridiculous, arbitrary limit.In any case, this means that if you have enough traffic to accumulate 10K user timing hits per day, it means that the solution I provided in the previous article will not work for you, as the Pageviews will not be capped, meaning the calculation of Total Engaged Time / Pageviews will be skewed.

When looking at Google Analytics reports, you’d think you get a pretty good idea of how people are interacting with your site, right? I mean, you’re tracking events here, pageviews there, and user timings, custom dimensions, custom metrics, and calculated metrics are all part of your daily lingo. But you’re also probably aware of how futile this tracking is. After all, all you’re seeing are numbers that reflect certain outcomes the visitors have produced on the website, and how these outcomes match against your preconceived goals and objectives, right?

This is a really cool feature for Google Analytics data collection, of which I’ve heard very, very little buzz. It’s a way to debug any and all hits sent to the Google Analytics endpoint at https://www.google-analytics.com/collect. In all simplicity, you just need to copy the entire URL of the HTTP request to your clipboard, paste it into a web browser, and add /debug between the hostname and /collect.

Every now and then I run into a problem which needs some creativity to find a fix. When choosing a course of action, I tend to land first on an extremely complicated solution. However, if I’m patient enough, I manage to whittle it down to something far more manageable and efficient.In this #GTMTips post, I’ll show you one of these extremely simple solutions to a problem which you might normally overcomplicate.

In this article, I’m going to tackle one of the most frequently asked questions out there:Can you run Google Analytics using the snippet AND using a Google Tag Manager Tag on the same page? There are many facets to this query, so I’ll try to tackle as many of them as I possibly can.First, a terminology rant. You hear lots of talk about “on-page” and “inline” Google Analytics tracking, as that’s what’s used to describe the non-GTM way of tracking Google Analytics.

Hello friends! Today I want to direct your attention to a dangerous setting found within the bowels of the Universal Analytics Tag template in Google Tag Manager. In fact, GTM itself highly discourages you from meddling with it: I actually agree with this warning. It should be highly discouraged, as modifying the tracker name introduces a potential hazard to your tracking plan, unless you know what you’re doing.

Google Tag Manager’s Data Layer is something I’ve touched upon in pretty much all of my articles. It’s such an integral part of what makes a tag management solution great and applicable to a host of business scenarios. I’ve also talked at length about the internal data model of Google Tag Manager, and this #GTMTips post is very much related to this rather murky concept.In this post, we’ll go over the Data Layer Variable Version selection, and I’ll try to explain just what this selector does.

Welcome back my friends (to the show that never ends)! It’s been a couple of weeks since my last barrage of articles, and I think the time is ripe to do some testing!First things first, here’s a picture of me shovelling snow: And now back to the topic at hand.One of the things that seems to be a hot topic in Universal Analytics is cross-domain tracking. I’ve never really tackled the beast head-on, since there’s such a wealth of excellent articles about it out there.

Tracking YouTube videos in Google Tag Manager is one of the more useful things you can do in terms of tracking. YouTube has a wonderful API that you can tap into and convert the detected events into dataLayer messages.There are some really good solutions out there for tracking YouTube videos in GTM: The wonderful solution by Cardinal Path. An even more thorough treatment by Bounteous.

In Google Analytics for iOS, there are two types of campaign measurement. There’s install campaign measurement, which lets you track the channels which brought your visitors to the App Store, where they proceeded to download your app. There’s also launch campaign tracking, which lets you attribute app launches to specific campaigns.In this tip post, we’ll tackle the latter. We’ll leverage a feature of the Google Analytics iOS SDK to build the parameters, and then push them to dataLayer so that they can be used in the Tag.

One of the less-known features of Google Tag Manager, a hidden gem if you will, is the URL Source setting in the URL Variable type. It lets you parse any URL String for its components.Tip 38: Parse URL strings with the URL Source setting The setting itself is easy to find. Just edit an existing URL Variable, or create a new one. Then, scroll down to the More Settings divider, expand it, and you’ll see the URL Source drop-down list.

For some reason, you might run into a situation where you need to add multiple Google Tag Manager containers on the same page. Usually this is because of poor governance or an inflexible organization. My recommendation is to fix things in your projects first, and only resort to multiple containers if you can’t seem to resolve your governance issues using your vocal cords (or your fists).Officially, Google Tag Manager introduced support for adding multiple containers earlier in 2015.

(UPDATE 28 Sep 2016: The official recommendation has finally caught up with the times. Now the correct placement for the JavaScript methods of the container snippet is, indeed, in <head>.)I want to address something I’ve been confused about from the very first day since I started using Google Tag Manager. Why on earth would an asynchronously loading JavaScript library be recommended to place in the beginning of <body>, when the logical place to start loading dependencies is as early as possible in the document load process?

There might be many reasons you’d want to fire a single Tag multiple times in Google Tag Manager. The most common one is when you want to deploy multiples of a single tracking point on the web. Perhaps you have a roll-up account you want to send the hits to, in addition to the site-specific tracking property.Quite a while ago, I gave a solution for this with a specific focus on Google Analytics Tags.

A while ago I wrote a blog post about how to install Google Tag Manager for iOS using the Swift programming language (you can read the article here). I’ve been doing a lot of work with Swift lately, and I’m more and more convinced that GTM is actually a very powerful utility for running in your iOS app instead of the Google Analytics SDK.Why? Because it abstracts a lot of the nitty-gritty you’d otherwise need to explicitly manage in your GA installation.

You might have noticed that the Referral Exclusion List in Google Analytics is difficult to maintain. You can’t copy a list from one property to another, the list is a wildcard match for domain names (so all subdomains are automatically excluded), and it’s just about the clunkiest user interface we’ve seen since ERP tools from the 1990s. A while ago, I wrote of a solution which lets you manage referral exclusions using Google Tag Manager, and it’s still a neat trick, as it’s way more flexible than said clunky UI.

Google Tag Manager, our favorite free tag management solution, has always struggled with its enterprise-worthiness. There are many features still lacking, most of which have to do with working in multi-user environments. Now, grab the last word of that sentence (see what I did there), and hug it tightly, for GTM just introduced a new, enterprise-friendly feature: Environments. These Environments are actually browser cookies, which you use to link a Google Tag Manager container state with the browser of the user who needs to or wants to view that particular state.

This year I had the opportunity to present at eMetrics London and Berlin on a topic that is very close to my heart. I’m psychotically neurotic about data quality. I’ve written about it many times before, and it’s pretty much why I want to keep on blogging and writing about analytics and tag management customizations. At eMetrics, I stepped out of my comfort zone of development and implementation, and chose to talk about organization practices.

NOTE! This solution has been upgraded, and the new approach can be found here. If you’re unfamiliar with the lingo, cross-domain tracking is a hack used by Google Analytics to circumvent the web browser’s same-origin policy. Essentially, the policy dictates that browser cookies can only be shared with a parent domain and all its sub-domains. In other words, domainA.com and domainB.com do not share cookies.Since Google Analytics calculates sessions and users by using a cookie, this is problematic.

I’ve been meaning to write about Google Tag Manager for mobile apps for such a long time. Finally, I have some great use cases to share, as well as some useful examples for implementing GTM for iOS. That’s right, this is an iOS guide, and, to be more specific, geared towards a successful Swift implementation. If you didn’t know, Swift is a relatively new programming language, developed by Apple for iOS and OS X programming.

So, looks like iOS 9 has built-in support for integrating “content blocking” extensions on your iPhone. Now, blocking ads and other intrusive content is nothing new, nor do I want to get into a debate about whether it’s a good thing or not. But as a data geek I’m very interested in knowing just what share of my site tracking has some content blocker enabled. In this post, I’ll show two tricks (easy and advanced) to expose these content blockers.

Here’s an interesting and hacky use case for you. It’s all about uncovering bounce metrics for visits which originate from organic Google search results. In particular, the metric we’re interested in is how long user dwelled on the landing page after arriving from organic Google search AND returned to the search engine results page (SERP) using the browser’s back button. The inspiration for this post came from an audience question at the Best Internet Conference in Lithuania, which I recently attended as a speaker.

Every now and then we want to create a bridge between the stateful machines we send data to (e.g. Google Analytics), and the stateless environment where we collect the data itself (e.g. Google Tag Manager). This is not easy. There is no synergy between Google Analytics and Google Tag Manager which would let the latter understand anything about things like sessions or landing pages or Bounce Rates.One thing we can reliably measure, however, is whether or not the visitor is a New User in Google Analytics.

Enhanced Ecommerce is undoubtedly an excellent feature of Google Analytics. It provides us with a set of reports that truly extend the capabilities of funnel-based website analysis. As I’ve shown before, it’s also very useful for tracking other transactional events on your site, such as content engagement. However, here’s the thing. It’s not very easy to implement. Even if you get everything right according to the documentation, there are still quite a number of pitfalls, and many of the learnings emerge only through experience.

Unfortunately, iFrames still exist. They are used to embed content from one page into another. Frames are horrible, nasty things, very often riddled with cross-domain problems, performance issues, responsive design obstructions and other crap from the nether pits of hell. Regardless, if you’re stuck with an iFrame which also collects data to your Google Analytics property, for example, you probably want to prevent at least the first Page View from firing, since otherwise you’ll be double-counting Page Views: once on the main page and once in the iFrame.

(Updated 13 August 2017)A little over a year ago, in April 2014, I wrote the post “Advanced Form Tracking In Google Tag Manager”, and it’s been at the top of my best seller list ever since. Turns out that many people are rightfully passionate about making the web forms on their websites as fluid and intuitive as possible, since a web form is often the only thing that stands between a prospect and their transformation into clienthood.

A recent update to Google Tag Manager introduced a feature which has been on the wishlist of many users for a long time. It’s called Tag sequencing, and its purpose is to facilitate the sequential firing of Tags. The idea is that you can specify a setup and a cleanup for each Tag in your container. This article is intended to function as a quick tour of the feature.

The web is stateless. It’s basically blind to your past, and it does a poor job of predicting what you might do in the future. When you browse to a website, the browser requests the page from the web server, and then proceeds to render it for you. This is a detached, clinical process, and any personalized or stateful data transfer is left to the sophistication of your web server.

With the advent of Enhanced Ecommerce for Universal Analytics, a new scope was introduced for Custom Dimensions and Metrics. Product scope can be used to send information about each product that is sent through Enhanced Ecommerce, but it’s not exactly the most logical or intuitive thing to wrap your head around.In this #GTMTips post, we’ll take a look at how to implement Product-Scoped Custom definitions via Google Tag Manager, and I’ll quickly explain how they work in relation to queries and reports you might want to build on top of them.

To prevent a Tag from firing in Google Tag Manager, you can: Delete the Tag Remove all Triggers from the Tag Add an Exception Trigger to the Tag The third option is usually the best if the blocking is just temporary. Exceptions are what used to be called blocking rules in the first version of GTM. To add them is easy enough. In the Fire On step of Tag creation, you can click Create Exceptions, and choose the Trigger that will block this Tag from firing.

The inimitable Craig Sullivan gave me an idea for a continuation to my latest post on form abandonment tracking. In this short tutorial, I’ll show you how to track the time users spend on your form fields. We’re going to use the User Timings hit type, and we’ll send the data for just one form. With small modifications, you can expand the script to cover multiple forms on a page.

Form abandonment isn’t always easy to define. Most often, it refers to when someone starts to fill in an HTML form, but leaves the page without submitting it. As a definition, this works nicely. However, with multi-page forms it naturally refers only to the last page of the form. Also, especially with government institutions, forms can be saved to be submitted later. Here, again, form abandonment must be reconsidered. In this article, I’ll go over four different ways to track form abandonment in Google Analytics, using Google Tag Manager to setup the tracking.

In JavaScript, if you want to access an Array member, you use square bracket notation to retrieve the value stored at a specific index. Indices are numbered in order, with the first index always being at location zero (0). This means that to get the first value stored in Array simo, you’d use something like:var firstValue = simo[0]; In Google Tag Manager, you can push Arrays into the Data Layer.

Maintaining the list of Referral Exclusions in Google Analytics admin is a pain. Especially if you have a webstore, the number of referral sources you need to exclude to avoid sessions being split can grow really fast. Also, it’s not like the list is has the most intuitive UI. Instead of a handy text area where you could just copy-paste stuff, you’re left with a horrible line-by-line list, and there’s no way of copying lists across properties or anything useful like that.

What a nice way to wake up to a new day, when brand-spanking new features have been released for Google Tag Manager.The two features I want to introduce here are Folders in the UI, and code syntax highlighting in Custom HTML Tags and Custom JavaScript Variables.Folders Folders is one of those features that has been requested for over and over again since day one. The UI clutter in GTM is a serious problem, especially when dealing with dozens and dozens of items in a single view.

One of the glaring omissions in the Enhanced Ecommerce reports of Universal Analytics is the ability to calculate cart value for products. Cart value, here, is the value that has been added to the cart.This value can be used to query for products that have the highest discrepancy between cart value and generated revenue. These are missed opportunities of the highest caliber.With some Custom Metrics magic, we can, however, get cart value into our reports, and we can find our most and least “effective” products with just a glance:

Enhanced Ecommerce is a very nice improvement to the pretty lame, transaction-based Ecommerce tracking in Universal Analytics. Instead of staring blindly at what happens on a receipt page, Enhanced Ecommerce expands your entire webstore into one large funnel labelled “Shopping Behavior”, and you’re able to zoom in on the Checkout funnel as well. Also, the addition of product-scoped tracking is incredibly useful, and it’s enabled us to think of any asset (our content, for example) on our site as something we could track through the Enhanced Ecommerce reports.

Wait. What? Why write an article about something that should work by default in Universal Analytics? I mean, here’s a screenshot from the guide I just linked to in the previous sentence: There it is. Clear as day: “Tracking users across subdomains does not require any additional configuration.” Also, some of the recent, excellent guides to cross-domain tracking, written by E-Nor and Bounteous enforce the same: you just need a default Universal Analytics Tag in Google Tag Manager.

Here’s a tip that’s especially important to anyone working with a single-page application. Google Tag Manager persists items in its data model until you either manually delete the variable and/or its value from the data model, or until the user browses away from the page. There’s nothing as annoying as the example in the image below, where a value that was set for an earlier Tag is resent with a new Tag, even though the purpose was to leave it out.

PII (Personally Identifiable Information) is something we need to actively combat against when using Google Analytics, as the platform explicitly forbids sending PII to Google Analytics properties in any size, form, or shape.One of the most common ways of accidentally passing PII to a property is via query parameters. Many email platforms out there, for example, see no problem in including the user’s email address in the query string, especially when the user follows a link in a newsletter.

According to their website, SoundCloud is “the world’s leading social sound platform where anyone can create sounds and share them everywhere”. For artists, it’s a channel for distributing previews of their tracks, and for people like me it’s a nice way to do some API tinkering. To each their own, I guess! I saw a number of requests in the Google+ Google Tag Manager community about a SoundCloud integration, so I decided to look into it to see if I could just build one.

Are you (even marginally) interested in one of the most powerful tag management systems out there? Do you want to refresh your memory on how JavaScript works in the web? Do you want to get the most out of Google Tag Manager as the go-to system for all marketing and measurement tagging on your websites?Take the Google Tag Manager Fundamentals Course at the Analytics Academy, then! And take it even if you have no idea what the tool is.

This is a very simple tip, but judging by the number of queries on the Product Forums, it should prove helpful.Blogger is a free blogging service by Google. Like WordPress, they allow you to run hosted blogs on the blogger.com domain, and they also allow you to modify the HTML source. This, of course, means that you can add the Google Tag Manager code to the HTML template, if you wish (and why wouldn’t you!

Google Tag Manager has a learning curve. We’ve all gone through it. The developer guide as well as the new and improved help center are very useful, but they do not answer all the questions a thorough implementation project might face. There are many ways to find answers to your questions, and I thought I’d go through some of my favorite options here.Tip 22: Get GTM Assistance To help you in getting help with GTM, there are two things we’ll need to go over: where to look for help, and how to ask for assistance.

Data is difficult. Growing a business is difficult. Measuring success is difficult. And you know what? They should be difficult. Otherwise we’d all be equally stupid, whereas now those of us ambitious enough to exert themselves are winning the race. And it’s not just working with data that’s difficult. The whole Web is a mess! Search engine optimization consultants, for example, are trigger-happy in doling out advice about server-side redirects without stopping to consider the implications of what they’re recommending.

Last weekend, I wrote a very simple web app that automatically creates a number of referral spam filters to tackle the problem that seems to have everybody all riled up. For a nice recap of the situation, take a look at this post by Jeff Sauer, or this article by Mike Sullivan.This isn’t an opinion piece, even though I’ve got a great number of opinions about this issue.

There are many tools and methods to make Google Analytics more manageable. Google Tag Manager is probably the best known of these, and you can find many, many articles about GTM on these pages as well.However, today I want to tell you about one of the features of Universal Analytics that hasn’t, as far as I know, received too much attention. It’s funny, because at the same time almost everyone uses the feature in the shape of eCommerce, enhanced link attribution, and cross-domain tracking.

Here’s a very quick tip this time, but one that’s caused a lot of headache for many Google Tag Manager users.Tip 21: Use the All Pages Trigger correctly Let’s face it, All Pages isn’t really an intuitive Trigger name. Many seem to interpret it as: enable the Tag to fire on all pages, but use the other Trigger (e.g. Link Click) to actually fire it.As it turns out, the All Pages Trigger will fire the Tag on all pages.

A year ago, I wrote a Year In Review post for one of the craziest 365 days of my life, both personally (got married), and professionally (started at NetBooster, and toured the world talking about Google Analytics and Google Tag Manager). Now it’s time for another recap, and the chance to announce a big change in the Simoverse. No, I will not be joining Google (made you think so!

If you read my previous post on fetching the Client ID from the Universal Analytics tracker object with Google Tag Manager, you might have agreed with me that it sucks you can’t access the tracker object interface in real time using Google Tag Manager. This is because all of the set commands you add to a Universal Analytics tag template take place before the analytics.js is loaded and the tracker object is properly created.

Since writing my rant about the schema conspiracy of web analytics platforms, I’ve been giving the whole idea of hit-level data collection a lot of thought. Sessionization is very heavily implemented in Google Analytics, which is understandable, but the regular Google Analytics API just doesn’t give you the kind of information you’d need, if you wanted to stitch hits together differently in your own backend. In fact, there are four distinct levels of aggregation that are not exposed via the API, even though I think they should:

On March 30th, right on (the latest) schedule, the Migration Assistant tool was published for Google Tag Manager V2. This tool lets you opt-in to account migration for your legacy Google Tag Manager Accounts. Migration means simply that the accounts will be converted to V2 accounts, and you will have access to all the new features the upgrade provides.In this #GTMtips post, we’ll go over the migration steps (it’s pretty simple), and I’ll leave you with a couple of tips on how to get started with the new features.

One of the unfortunate misunderstandings regarding the wonderful Google Tag Manager Preview mode is what it actually means when GTM reports “Tags Fired On This Event”. For many, this seems to indicate that whatever code the Tag was meant to execute also completed successfully. However, this is not the case.Tip 19: Debugging Tag execution vs. actual requests Let’s get the distinction straight right away:Google Tag Manager debug panel tells you when a Trigger has been invoked by certain conditions, and the Tag which uses this Trigger has its JavaScript injected into the Document Object Model.

In 2013, I wrote a guide for Universal Analytics and Google Tag Manager on how to poll for weather conditions, and send this information to Google Analytics as a custom dimension of the session. The guide was intended as a technical introduction to Google Tag Manager, and I think it succeeded in that.However, GTM has changed a lot over the last 1.5 years, and I’ve made some improvements to the method along the way.

(Updated 15 July 2015: Added a huge simplification. Jump straight to the update at the end.)URL fragments are strings of characters that follow a hash mark (#) in the URL. Typically, they are used for anchor links, where following a link keeps you on the same page but jumps the browser to some anchored position. They’re also the tool of choice for single-page apps, where content is served dynamically without page reloads.

A schema is something that data processing platforms such as Google Analytics apply to the raw hit data coming in from the data source (usually a website). The most visible aspect of Google Analytics’ schema is how it groups, or stitches, the arbitrary, hit-level data coming in from the website into discrete sessions, and these are actually grouped under yet another aggregate bucket: users.But you already know this. You’re looking at metrics like Sessions, Bounce Rate, Conversion Rate, and you’re using them or variations of them as KPIs in your dashboards and whatnot.

In Google Tag Manager, every single Tag requires a Trigger to fire. Every single Trigger requires an Event condition to activate. Sometimes, these Event conditions are obfuscated under template semantics, but you can also create a Custom Event Trigger, where you specify the value of the ‘event’ key in dataLayer that fires your tag. You can read more about the relationship between GTM events and Tags in these two posts:

Be honest, can you think of anything that’s more unfair than this: A new Google Tag Manager feature, published at 02:07 AM my time, and with an easter egg hunt involved?! Of course it was the infuriating Charles Farina who found the new feature and claimed the prize. Curses! (Just kidding Charles, you’re still awesome.) Anyway, there’s a new GTM feature in town, and oh boy, this time it’s a big’un!

This nifty little solution will let you calculate the time spent on pages that are not tracked in Google Analytics by default. These include both bounced landing pages and exit pages. Bounced pages and exit pages lack the necessary subsequent pageview, which Google Analytics uses to calculate time-based metrics.Before you go on, read this excellent article by Yehoshua Coren:REAL Time On Page in Google AnalyticsYehoshua gives a very nice use case for the technical solution I’m about to explore.

Due to a recent change in the UI (see entry for February 12, 2015 in the release notes), the large and ever-expanding group of fields you could set for your Universal Analytics tags has been mostly removed. Instead, the often obscure Fields to Set selection has been promoted to the top of More Settings, and you control most of the Universal Analytics fields through this selector.In this #GTMtips, we’ll take a quick look at what’s changed, how it’s changed, and how to work with this new, slimmed-down tag template.

Quick history. On May 23, 2014, the following announcement was made on the Google Webmaster Central Blog:In order to solve this problem, we decided to try to understand pages by executing JavaScript. It's hard to do that at the scale of the current web, but we decided that it's worth it. We have been gradually improving how we do this for some time. In the past few months, our indexing system has been rendering a substantial number of web pages more like an average user's browser with JavaScript turned on.

One of the big mysteries in browser-based data collection platforms like Google Analytics is what happens when the visitor is not being tracked. This is most obvious in cases where the user explicitly opts out of tracking, when the user does not have JavaScript active in their browser, in bounced sessions, and on exit pages.Opt-outing means that the user explicitly prohibits a website from tracking them. In some cases, it’s possible that opt-out is the default, and the user must explicitly opt-in to allow GA to record their visits.

In this #GTMtips post, we’ll go over a simple method for tracking file downloads in Google Tag Manager, specifically the new, V2 interface. Also, “tracking file downloads” means sending Events to Google Analytics, so this is a GA for GTM guide as well.Tip 15: Set up file download tracking in GTM Since we’re using Google Analytics as the tracking platform, we’ll need the following ingredients to make this setup work:

NOTE 30 Oct 2019: I’ve published a new article on outbound link tracking in Google Tag Manager, which makes the whole process much, MUCH simpler. I strongly recommend you read that article instead. Tracking outbound links is important for many. Identifying the exit paths is almost as important as tracking entrances. In this simple #GTMtips post, I’ll show you how to track outbound links with a simple Trigger + Auto-Event Variable combination in the new Google Tag Manager interface.

(UPDATE 3 Apr 2017: There is a newer version of GTM Tools out, so please ignore this article and read this one instead.)So, the time has come to update my GTM Tools. I released the first toolset in October 2014, and it performed its duties just well enough. Sure, the UI was ugly as hell, and there were bugs along the way, but for cloning containers, macros, and rules, and for visualizing containers, it was just good enough.

Google has a myriad of ways to make the search engine results page (SERP) livelier. When you input a search query, the engine’s mission is to provide you with the most relevant information with as few clicks as possible. Often, this means that you’ll see the answer to your query directly in the SERP: See also Dr. Pete’s excellent description of variation in the SERP (note that this post is from 2013, and not all the data types are relevant today).

With Google Tag Manager, there are a million different ways to make your tagging setup leaner and more flexible. The reason this should be a priority is because the UI isn’t perfect. The more tags you have, the more difficult it becomes to manage your assets.In this #GTMtips post, I show you one of my favorite ways to put your container on a diet.Tip 13: How to create a Generic Event Tag I’ve seen a lot of containers that suffer from the same problem.

You’ve probably heard of the Konami Code. It’s a cheat code in many Konami games, where the cheat is executed with a sequence of key presses on the keyboard. Since then, it’s become one of the staples of video game folk lore, and many websites, games, and applications have their own easter eggs activated with the Konami code.The sequence of keys is:up, up, down, down, left, right, left, right, B, A

(Updated 21 February 2019)The current version of Google Tag Manager was released in October 2014. With the release, we saw a brand-spanking new UI, a lot of new functionalities (revamped auto-event tracking, for example), plus a new terminology to cope with. We moved away from the programming-centric concepts of Macros and Rules to the more tactile variables and triggers.It’s difficult to rank the changes. The new Auto-Event Tracking is perhaps most impactful, but the improvements done to triggers and variables, when compared to the previous version of GTM, require attention as well.

My fingers have been tingling to write this article. Ever since I implemented Enhanced Ecommerce on my blog a couple of weeks ago, I’ve been getting such an impressive amount of useful data that it’s mind-boggling.In this article, I’ll walk you through the steps I went to implement the solution, along with examples of the data I can now access through Google Analytics’ reporting interface. As you might have guessed, if you’ve read my articles before, I implemented Enhanced Ecommerce with Google Tag Manager.

In this tip, we’ll take a look at how to leverage a custom first-party cookie to prevent repeat hits of any kind. This is most useful for transactions, since a common problem with Google Analytics (traditional) eCommerce tracking is that a transaction hit is sent again upon subsequent entries to the receipt page, for example using the Back button of the browser. In some cases, and this is not a good practice, a receipt e-mail is sent to the user with a link back to the receipt page, where the transaction is sent over and over again upon entry.

Updated 27 March 2019 In the new version of Google Tag Manager, one of the most visible and profound changes to the previous version is how tags are fired (and blocked). First of all, there’s the obvious terminological distinction: we talk about triggers now, not rules. Second, triggers have become an integral part of the tag creation workflow, and as such have far more significance in the user interface than before.

One of the recurring problems in migrating to Google Tag Manager is how to make the transition as smooth as possible. Usually it requires that we agree with the developers on a time when the old code is removed, and at that moment we need to make sure the GTM tags point to the right UA code. This is, of course, only one use case for migrations, as some people do the entire migration in a staging environment, and some just don’t care if they lose a little bit of data along the way.

When our good friends in the Google Tag Manager developer team first introduced the Lookup Table Macro, we were excited. For many of us, it soon became the weapon of choice especially when used as a management and optimization tool for the container itself. However, the macro wasn’t considered perfect. In fact, the most frequently heard request had to do with the core functionality of the feature itself: the macro should support operations, that is, predicate logic.

I’ve written about this before here and here, but this issue remains probably the biggest problem users have when implementing Google Tag Manager.Tip 10: Resolve conflicts with GTM’s listeners The tip title is actually wrong. You’re not fixing Google Tag Manager listeners. Rather, you’re resolving conflicts that other scripts on your page might introduce.GTM’s event listening is based on something called event delegation. Event delegation makes use of the document object model (DOM) and its tree-like hierarchy.

If you use Google Analytics, Google Tag Manager, or any JavaScript-based data collection or analytics platform, have you ever stopped to wonder how they actually work? I mean, you obviously care about getting the data in, but are you taking the machinations of these tools for granted?This is something I’ve been thinking about for a long while, because I’m not so sure that many who work with these platforms actually understand how the browser and the web page interact.

If you haven’t lived in a barrel, you should know by now that a new version of Google Tag Manager has been released. You can find the new version at http://tagmanager.google.com/, and there’s already a bunch of good articles about the new UI out there. I want to point out two: “Setting up GA via GTM’s new UX” by Krista Seiden, and “Google Tag Manager Refresh – 6 Things You Need to Know” by Jonathan Weber from Bounteous.

In the new version of Google Tag Manager, auto-event tracking has received a considerable usability upgrade. It might seem quirky at first, especially if you’re used to the old auto-event tracking method, but the logic behind the new setup is brilliant. The most important distinction is that auto-event tracking isn’t something you control with separate tags anymore. Rather, it’s now entirely trigger-driven, meaning you activate and specify the auto-event tracking of your choice using tag triggers (triggers are what ye olde folk used to call rules).

The User ID is definitely one of the coolest things about Universal Analytics, if used correctly. It might reveal some surprising insights about your visitors, since now you’re not restricted to analysing visitors as just browser or device instances as before, but rather you can build your stories around all the touch points the user might have had on their journey to and through your web properties.With this simple tip, you can extend User ID tracking to return users without them needing to authenticate.

I’ve written a bunch of tools to help you use and debug Google Tag Manager and Google Analytics. I’m neither a professional product developer nor am I a visual designer, and both correlate with how the tools look like and what their user experience is :)Nevertheless, I only create tools that I want to use myself, and being a sort of power-user especially in the development side of things, I do think that these little utilities provide added value to your tag management needs.

I’ve written a completely revamped version of this toolset for Google Tag Manager V2.Well, I just yesterday published the first of my GTM API tools (the Container Visualizer), and I vowed that I wouldn’t release the other tools for a number of reasons.The reasons were good, in my opinion (especially the part about the tools being ugly as crap), but on the other hand I don’t want to keep anyone away from the amazing potential of the new API.

[UPDATE:] Quite a lot of people had trouble accessing the tool after I published this post. This should now be fixed.So, AWESOME stuff. The new Google Tag Manager UI and API have just rolled out, and I can finally start revealing the stuff I’ve been working on :)I’m not going to go into the new UI in this post. I just want to give a huge thanks to the GTM team for working on the UX with such dedication.

Here’s a tip on how to avoid a horrible, horrible mistake with Google Tag Manager.Tip 7: Always use .push() with dataLayer When you assign a value to a variable using the equals ( = ) sign, you are actually reallocating the variable to a new value, and the garbage collection system of the runtime environment sweeps the previous value to bit heaven.Let’s put it simply: if you redefine dataLayer after the GTM container snippet, you will break GTM’s proprietary functions.

I’ve noticed that setting up eCommerce in Google Tag Manager (and now the new Enhanced ecommerce) is very difficult for many. I’m sure part of the problem is that eCommerce is for many users the moment that GTM forces you to take steps in to the developer’s domain, since it’s obvious that you’ll need to add some code to the web page.This isn’t a tutorial on how to do eCommerce in Google Tag Manager.

This time we’ll take a look at two different, JavaScript-y features of Google Analytics and Google Tag Manager. Callback as a concept should be familiar to anyone who’s ever used a programming language. It’s basically a piece of code that is passed as an argument to some function, so that when this second function has completed, the callback is executed.For web analytics, callbacks are hugely important, since they allow you to impose a firing order for your asynchronous tags.

One of the cool things about using a tag management solution is that you can leverage variables like never before. In Google Tag Manager, these variables are referred to as macros, and you can identify a macro with the syntax of {{macro name}}. In this tip I’ll show you how you can actually call macros from other macros, using a Lookup Table as an example.Tip 5: Chain Macros In Lookup Tables (And Other Macros) It’s not just Lookup Tables, either.

It’s time for MeasureCamp again! As before, I want to write an accompanying post for my session, since there’s always so much more to say than the time slot allows for. So, the topic of this article is the data model used by Google Tag Manager to process digital data in your data layer.This post also picks up where I left in my previous foray into the data layer. However, where the first article aimed to be generic (since the data layer should be generic), this post will look at how GTM uses the information in the generic data layer, and how it processes this information to work with the proprietary features of the tool.

The Page Visibility API for web browsers is pretty sweet. It lets you poll, using some new properties of the document object, whether or not the current page is visible to the user. Visibility is hidden if the page is not open in the current browser tab instance, or if the browser window has been minimized. In this post, I’ll give an example of how features of the Page Visibility API could be used with Google Tag Manager.

This might not sound like a tip to you. You might think, “Dimensions won’t get sent? Sounds like a bug!”. You’re wrong. This is one of the awesome features of the GA API, and it’s key to making your tag setups leaner when sending data to Google Analytics.Tip 4: Undefined dimensions are left out of GA hits Note that ‘undefined’ here means the special value undefined in JavaScript.

Writing this article is dangerous. Data Layer is two marketers short of becoming a buzz word. This occasion will be heralded by articles such as “Data Layer Is Dead”, “This Developer Implemented A Data Layer And You’ll Never Guess What Happened Next”, and other examples of the kind of content generation whose propagation should be prevented by military force. This is not one of those articles, I hope, but rather an honest look at what Data Layer is from a number of perspectives.

Rules are the cornerstone of Google Tag Manager. As with any critical element in a system, they are easy to get wrong. This tip is just a refresher on how GTM firing and blocking rules work.Tip 3: Google Tag Manager rules in a nutshell So, let’s go through these points one-by-one.Every tag requires a firing rule to work - this is a given. Without a firing rule, your tag will not be written in the document object, and it will never be executed.

Here’s a simple way to check what was the source of the visitor’s arrival to the current page. It’s done by utilizing the {{referrer}} macro, which comes out-of-the-box in any GTM setup.Tip 2: Use {{referrer}} to see where the visitor came from You might want to also explore the Component Types and create new macros for {{referrer path}} and {{referrer host name}} for example: By default, you see, the {{referrer}} macro returns the entire URL of the previous page.

I wanted to try something new (and, naturally, I’m running out of content ideas), so let me introduce the hashtag #gtmtips. I hope others contribute as well, but I will be adding a new tip as often as possible. I’ve got maybe 20 tips in store right now, and I’m writing new ones all the time. So without further ado, here’s…Tip 1: Save GATC In A Constant String Macro This is an easy one, and everyone should already be doing this in one way or another.

(Update 19 November 2018: See this article for a more elegant solution.)If you know your JavaScript, you know that all variables, functions, objects, resources, and data in the document get rewritten with every page load. In other words, every single page refresh builds the page from scratch, and the state of the document before the page refresh is left drifting in the ocean of oblivion.Google Tag Manager’s dataLayer is also one such entity.

There’s a much easier, native-to-GTM way to do this now: the Matches CSS Selector.Behind this tragically boring title is a simple solution to many problems with Google Tag Manager’s auto-event tracking. The common denominator to these problems is poor website markup. Selectors are used sparingly, and element hierarchy is messy. This disregard for proper node relationships means you have to resort to Data Layer Variable Macros which look like

(UPDATE 1 Oct 2014 Due to a change in how macros work in Debug Mode, the {{generic event handler}} macro no longer works when testing in Debug Mode. That means that you’ll have to test your custom listener in a live container (I know, ouch!). If you want to test in Debug Mode, you’ll have to skip using the {{generic event handler}} as a macro, and instead copy the inner function into the Custom HTML Tag, give the function a name, and use that as the callback in addEventListener or attachEvent.

It’s been an awesome summer, with temperatures soaring in the global warming range throughout our northern country. The heat has given me ample reason to not be near a computer, but now it’s time to mine some JavaScript wisdom again. Here’s the second part of my JavaScript for Google Tag Manager series. The first part focused on GTM specific tips and tricks, and I hope that while reading it, you were treated to another grand example of the flexibility of this wonderful tool.

I created a new Chrome Extension: Internalize for Google Analytics. This is its very first version. It only works on websites with Universal Analytics.Click here to download Internalize for Google Analytics v1.0The idea is that with the extension you can push a custom dimension value to your currently active session. You can then use a profile filter in GA to block traffic with this custom dimension value. It’s useful when blocking internal traffic with more traditional means (IP address or various GTM workarounds) won’t work.

Analyzing what people write in your site search field is pretty much one of the smartest things you can do for your website tracking. If certain terms pop up over and over again in internal search reports, it means that your site is not providing the answers people are looking for, meaning you have an excellent opportunity to provide supply for the demand! However, not all site search applications are trackable out-of-the-box.

Here’s the link to part 2 of this JavaScript guide.The thing about Google Tag Manager, or any JavaScript tag manager for that matter, is that there’s JavaScript involved. In fact, the tool itself is just a JavaScript library with some additional bells and whistles (such as a management UI). This means that to make the best of it, some knowledge of JavaScript is warranted, and that’s the point of this post.

Apologies for leaving you hanging. It’s now almost three weeks since I published the first part of this post, and I’m sure you’ve been holding your breath ever since.There’s been a lot going on since the last post. First, my favorite sports team in the world, San Antonio Spurs, won their fifth NBA championship from the defending champs, Miami Heat. Next, my wife and I moved to our new house, and we’ve been remodeling ever since.

It’s time to dig into my tip library for some pretty cool things you can do with Google Tag Manager to enhance your site tagging. Some of these are macro magic through and through, some of these are best practices, and some of these are things that will make your life easier while managing a tag management solution. I’ve split this post into two parts to make it more Hobbit and less Lord Of the Rings length-wise.

That’s right, I changed the name! Huge thanks to Paul Gailey for the inspiration.Get the latest version of GTM Sonar here.Just a minor update this time. I added some informative text to the pop-up, along with an error screen if something goes wrong. Another change is that now when an element is added to debugDL, a counter on the Browser Action icon will start climbing, representing the number of objects in the array.

(Last updated June 2014: Read the latest post on the extension, GTM Sonar v1.2.)I updated my Chrome Extension, GTM Auto-Event Listener Debugger v1.1. I released the first version a couple of days ago. The extension can be used to debug Google Tag Manager’s auto-event tracking and its compatibility with web page markup.Download the latest version here.I did some major changes, and here’s the rundown. I transferred all debugger actions into a pop-up, which opens when you click the Browser Action.

(Last updated June 2014: Read the latest post on the extension, GTM Sonar v1.2.)Many of the Google Tag Manager articles on this blog could be considered hacks, in that they extend the out-of-the-box features of GTM in ways that will surely not be officially supported by Google. The crux of the problem is that lots of folks are taken by surprise when GTM refuses to work properly on their site, or when they have trouble tracking key elements on the page template.

…or How My Organic Traffic Went Through The Roof.It’s been one of the craziest 365 days in my life, and I thought it would be apt to write a bit about all the stuff that’s taken place. I haven’t really been talking about myself in my guides and other previous posts, so please indulge me, for once!The beginning A year ago I had just quit my job at my previous employer, Innofactor Plc.

Over the last couple of posts I’ve mainly been doing proof-of-concept (POC) tests with Google Tag Manager. The great thing about a POC is that you don’t really need to have any viable results or insight-driving technological innovations. The point is to showcase some feature of the platform on which the experiment was conducted.In this post, I’ll take a care-free step into the world of POCs again. My goal is to do a simple split test in order to identify which variant of a landing page (or key element thereof) produces the most conversions.

Let’s say you want to set up a rudimentary email alert system in your Google Tag Manager implementation. Say, for example, you want to receive an email every time an uncaught error occurs on your website. It’s not a very good use case, since a large website can spawn hundreds of uncaught exceptions in a short period of time, but let’s just pretend for now.If you know your JavaScript, you’ll know that you can’t send mail using client-side code.

In this post, I’ll walk you through a tutorial on how to create a Google Tag Manager extension. This extension will be a new listener, whose sole job is to listen for changes in the HTML and CSS markup on the page.The reason I’m teaching you how to create a DOM listener is simple. Ever so often I come across people asking for help, but they are unable to touch on-page code.

If you know your Google Tag Manager, you know that GTM pushes three data layer events into the queue when any page with the container snippet is rendered. Each of these three events signals a specific stage in the page load process. Here are the events (be sure to read my guide on GTM rules to understand further what these events do): gtm.js - This is pushed into the data layer as soon as GTM is initialized and the container is loaded.

There is a new, updated version of this article for the new version of Google Tag Manager. I strongly suggest you read that as well!I really enjoy the ad hoc Q&A sessions my blog posts have inspired. I haven’t said this enough, but I am really, REALLY grateful to people who take their time to comment on my posts, even if it’s just say a quick “Hi!”. The main reason I enjoy getting blog comments is because they often turn into blog posts.

(Last updated June 2014) This post is an attempt at a whole new level of interaction. These words will transcend the barriers of time and space, bridging together the physical world and its digital counterpart. You see, in an undisclosed number of hours after the publishing of this blog post, I will be talking at the MeasureCamp unconference on this very subject. Or, I hope I will. The whole unconference thing is somewhat confusing, and it involves lighting-fast reflexes and street smarts for slot selection; traits which I sadly lack.

First of all, I’m sorry for the wacky title. Sometimes I just want to amuse myself. Nevertheless, this post is about the Google Tag Manager container snippet. There’s nothing secretive about it, but I’m betting many people have no clue what the snippet really does. That’s the revelatory part.If you’ve never wondered what the snippet does, then shame on you! Remember, you own your page template. It’s yours. Any code that you write there is your responsibility.

You’ve probably come across a number of guides or posts talking about why it’s necessary to block so-called internal traffic from your web analytics reports. The reasons are pretty solid: internal traffic does not emulate normal visitor behavior, it rarely contributes to conversions (skewing up your conversion rate), it inflates page views, and it wreaks havoc on your granular, page-by-page data.Internal traffic is vaguely described as “your employees”, “people really close to your brand”, “your marketing department”, “your web editors”, and so on.

Because I was bored, I did a quick test to sort out the firing order of competing GTM listeners. If you’ve done your homework (i.e. read my article on GTM listeners), you’ll remember that GTM listeners are set up on the document node of the document object model (DOM). I wanted to test what the firing order is if you have multiple competing listeners on the same page.I tested with the following listeners (make sure you read up on auto-event tracking if you are completely baffled at this point):

There’s a new listener in town! It’s a few days now since the Google Tag Manager team unleashed the History Listener, and the time has come for me to tell you what this baby can do.The History Listener is designed to be used on websites where content is loaded dynamically. Typically, these websites make heavy use of AJAX (Asynchronous JavaScript and XML), which is designed for loading content in the background and serving it dynamically without having to reload the page.

There is a new version of this guide for GTM V2 here.(Last updated April 2014) I see Google Tag Manager’s operational model as an analogy of Montesquieu’s three-branched government theory (don’t leave just yet, I’m getting somewhere with this). We have the legislative power of tags (what should be done), the judiciary power of macros (explore the context and circumstance of each tag), and the executive power of rules (make the tag happen).

Here are a few quotes I found on the web regarding tag management and IT departments:Relief of IT department bottlenecks – once the Tag Manager is deployed, new tags can be implemented directly by Marketing with no IT department involvement. This is a huge benefit for large websites, where IT is oftentimes a bottleneck. Original text here IT Issues - when you use a TMS like 'Google Tag Manager' you are bypassing the IT department.

When push comes to shove, I’m a pretty lazy guy. I enjoy nothing more than just to stretch my legs on a couch, pick up my iPad, and read what’s going on in the world. I skip the news, since they’re just full of depressing stories. Instead, I head over to my favorite Google+ communities to see what’s new in the blogosphere. This approach has led me to some pretty amazing individuals, whom I follow like a suckerfish.

Ever so often I come across a Google Tag Manager setup where GTM’s own auto-event listeners don’t perform the task they were supposed to. Listener problems seem to be a hot topic in Google+ and the Product Forums as well.There may be many reasons why your listeners don’t work, but a very common trend is that you have conflicting JavaScript libraries or scripts running on your page.Let’s explore how listeners work before tackling the problem.

I’ve written a new Variable Guide for Google Tag Manager, which covers the new GTM UI. This guide is for the old UI.You might be vaguely familiar with macros if you’ve ever used a computer. Basically, whenever you perform a complicated task with a simple gesture, or reuse complex code with a simple input mechanism, you’re using macros. Think keyboard shortcuts.In Google Tag Manager, this is the essence of macros.

Having just come hot of the press with my latest article on GTM and Content Grouping which, to my delight, Bounteous had written an amazing tutorial on earlier, Brian Kuhn and the amazing Google Tag Manager development team came out with another incredible new feature: The Lookup Table Macro.In software engineering, a lookup table is an array which takes away a layer of complexity in runtime computation, and replaces it with a simple value assignment based on array indexing.

Content Grouping is a nice new feature from the good folks at Google Analytics. Basically, it allows you to group your content according to a logical structure. You can create up to five Content Groupings, and you can have as many Content Groups within these groupings as you like. The difference between a Content Grouping and Content Group is hierarchy. The second is a member of the first. Read Justin Cutroni’s post on Content Groupings to get you started.

Have you ever stopped to think about what the chain of events was that led you to a particular decision? Maybe not, but in web analytics it is something that should be considered. After all, there is something counter-intuitive about analytics tools such as Google Analytics, which require us to think in terms of clicks and recorded events that occur on the website, during the visit.Thankfully, we have evolved as a species, and we no longer place too much emphasis on last click attribution.

(Last updated March 2014) This post is the final chapter of a trilogy. The ultimate refinement, if you will. It all started with my foray into the murky waters of context, when I tested how weather data could be used to provide extra information about site visits. When I wrote that post, I had two trepidations: 1) does sending the API call with every single page view affect site performance negatively, and 2) does forcing the page view call to wait for the API call to complete affect the quality of visit metrics.

There is a new version of this post for GTM V2 here.While going over my previous post about using weather conditions to segment data in Google Analytics, I started thinking about performance issues. Since I’m using a visit-scope custom dimension, it seems futile to have it send the weather details with every single page load. The odds of the weather changing drastically during one visit are slim (unless you live in the UK), and I have yet to come up with a good reason to change my on-site behavior because the weather changed from a drizzle to a downpour.

A word of warning. This is not a developers’ post, a guide, or a thought experiment. This is a bona fide rant. Sometimes we just need to vent.A couple of weeks ago, I checked one of our (inactive) client’s Google Analytics accounts I still had access to. What I saw in the acquisition report was this: See how direct traffic gobbles up a great big share of organic traffic in late October?

(Last updated June 2014) Google Analytics provides us with a nifty way of tracking social interactions. With a simple plugin, you can track how many +1s and Likes your pages accumulate.This guide shows you how to activate social interaction tagging with Google Tag Manager and Universal Analytics. The instructions are for Facebook Likes, Google+ +1s (now deprecated since Google Analytics tracks +1s automatically), Twitter Tweets and Pinterest Pins.Note that if you use a third-party API (e.

UPDATE 9 Oct 2013 - This works in Google Spreadsheets now as well! Feel free to make a copy of the sheet and work with the code. It’s still just a prototype, but I’m happy to see data bouncing from spreadsheets to Google Analytics.View the Google Spreadsheet hereORIGINAL POST Inspired by Daniel Waisberg’s excellent post detailing the use of Google Web Forms to send data to your Analytics account, I decided to create something similar.

I’ve had such a blast in the Google+ Google Analytics community. Not only are the people super-duper-nice, but I have the wonderful opportunity of helping people with their Google Analytics problems without feeling obligated to invoice them or ask for compensation for my troubles. I do it because I love to help, because I feel like I have a lot to share with the community, and because I’ve always believed that the more knowledge you share the more you accumulate.

There is a new version of this post for GTM V2 here.The Google Analytics Summit came and went, and thanks to the Live Stream, everyone could participate. We were treated to a rapid-fire selection of Google Analytics’ new features, and this post sheds light on one of these in particular: automated event tracking in Google Tag Manager.Auto-event tracking introduces a nice feature, which does what tag managers ought to do: it provides functionality without HTML template editing.

So here we are again. Universal Analytics and Google Tag Manager, the dynamic duo, ready to strike again.First, remember to check my previous two tips for UA and GTM use in custom scenarios: Weather as a custom dimension Tracking page load time In this post, I visit the idea of adjusted bounce rate, which I came across a year ago in the Google Analytics blog.Adjusted bounce rate basically refers to tweaking the traditional bounce rate collection method (single engagement hits / total visits) so that visits which only included a single page view would not count towards a bounce, as long as they met some qualitative requirements.

In Google Analytics, you can monitor your site speed and get a decent overview of what pages are contributing positively and negatively to site speed. The problem with page load time metric is that it’s an average based on a sample. You can modify the sample rate with setSiteSpeedSampleRate(), but for me that’s not bloody well good enough.(UPDATE 28.3.2014: This post is still valid, but an implementation with User Timings is a much smarter way to measure actual page load time.

There is a new version of this post for GTM V2 here.[Last updated June 2014] I’ve fallen in love with Universal Analytics and Google Tag Manager. Together they form an incredibly powerful tool for marketing professionals. In most cases, I no longer need to post recommendations to my client for yet another page template revision, since with the tag manager in place, I can just add custom code via the admin panel.

My days as a freewheeling, unrestrained, happy-go-lucky, gung-ho city cowboy are over. As of 31 August 2013, I’m a married man, and for the rest of my life, I will dedicate myself to optimizing my relationship to my beautiful wife. The old ball-and-chain. But before I bury myself in the bosom of our blessèd alliance, I’ll continue to blog about the dark and murky undergrowth of digital marketing that SEO is.

Dear client, search engineOptimization for you?Or perhaps - donuts?The Web, I’m afraid,Is a pretty sticky maze.And you’re the trapped fly.We tell you we’ll help,But you will not believe us.You are very wise.Everything we do,Everything we claim we do,You can do yourself.But if you let usApproach you humbly, gently,As a team, we’ll rock.We’ll rock Google, check!

So you’ve spent a whopping amount of money on paid search, SEO, Facebook ads, competitions, link building, and traditional marketing. You’re seeing a crazy influx of visitors to your site. Just as you’re about to call your boss to accept the promotion, you notice a worrying trend: your new visitors are barely making an impression on conversions from online traffic. What’s up with that? All your high-paid consultants told you that a high return of investment is guaranteed, since The Internet is da bomb, everything is cheap, and percentages are always in your favor!

So it’s been a while, I know. I’ve been enjoying my summer vacation, either swimming in the lush blue waters of Finland’s lakes or in the murky, greenish, (only slightly toxic) chemistry lab reject also known as the Baltic Sea. I’ve also had the pleasure of playing golf only to realize I’m roughly at the same skill level I was at when I first started. I blame the fact I’ve played less than ever before due to some unexpected patellofemoral pain in my right knee (yes, I know it’s called the Runner’s Knee, but if I know words like patellofemoral, I will use them).

Before I begin, it is important to note that SEO, as any other facet of web design, covers both technique and purpose. Technique in the sense that SEO comprises a number of de facto guidelines (and accompanying tools) which help improve the search engine friendliness of your website. With purpose I mean the elusive concept of setting goals, and how to pursue them. Both are incredibly important aspects of learning SEO, and it can be argued that one cannot exist without the other.

In a recent post, I took a short foray into the world of clumsy analogies by comparing the team work qualities (and necessities) of basketball and digital marketing. In an even earlier post, I made the claim that the single most important facet of content strategy is audience design. Well, now is the time to pull these two threads together all trilogy-like. After this, you can hail me as the Stieg Larsson of marketing.

So I was watching the 2013 NBA Eastern Conference Finals game 7 between Miami Heat and Indiana Pacers. While making note of the dozens of different ways that the lackluster Pacers were taken to the cleaners by the dominant Miami team (read: LeBron James), I started churning a funky thought in my head. This beautiful, wonderful, exciting, adrenaline-pumping, superstar-studded, tattoo-galore of a game must be an analogy of something. Something equally thought-provoking, exhilarating and life-changing.

I recently started rewriting some of the templates we use for SEO reports at my company. I first thought that the task would be a simple one. Just rewrite all the SEO stuff to match the latest trends, add more diagrams, charts, and graphs, and make it more personal by increasing the number of client-specific sections. However, soon I started to question my motives (as I usually do when doing something independently).

“Oh no, not another ‘SEO in a nutshell’ post!” I hear you scream. Oh yes! And to make matters worse, I’m actually calling this SEO In A Nutshell just out of spite! But why, oh why, must I litter the otherwise so clean and orderly forum that Internet is with yet another here’s-what-something-is-in-case-you-ever-cared-post? I promise, I’m only doing this for selfish reasons. I’m not trying to buy myself into the major league by posting about something that everyone else is posting about.

When Matt Cutts speaks, the world listens. We reach out our hands to catch even the tiniest morsels that make up the bread that fills the basket that is Google. We hush in anticipation, as we know that we are about to be revealed another piece of the puzzle that is Google’s search algorithms. We want to know these dark, esoteric, technological secrets because a) as humans we are genetically coded to abhor secrets and shadow-talk, and b) as SEOs we are competing in a business where only the first place is rewarded.

In this post, I propose that a combination of valid, accessible, and search engine friendly markup is the perfect recipe for optimal web design.For markup to be valid, it needs to conform to the guidelines laid out by the “governing body” of HTML standardization: the World Wide Web Consortium, or W3C. While the Internet anxiously waits for HTML5 to shift in status from candidate to recommendation, we’re stuck with ye olde HTML 4.

For years and years, the one constant in the chaotic world of SEO has been a simple statement: Content is King. This statement has been the cornerstone of content strategy in SEO projects, and its validity has hardly been contested. This is not due to lack of trying. Many posts in the blogosphere have taken an opposing stand (Heidi Cohen: format is king, Carl Ocab: marketing is king, Bernadette Coleman: trust is king).

You are right now enjoying the fruits of a very popular content management system, or CMS, whether you know it or not. This blog is published via WordPress, a modern CMS if there ever was one. In fact, if you add a comment to this post with the form below (hint, hint), you will be participating in content creation, using tools that come out-of-the-box in this particular platform. But what makes a modern CMS?

I’m hooked on Google Trends. For example, it probably won’t astound you to learn that whenever search trends peak for flu symptoms, there’s a similar peak for vaccine. (See also how at some points vaccine comes first and only then do flu symptoms arise. Conspiracy theorists, the ball is in your court!)Probing this particular case further, I looked at the search trends for swine flu and vaccine. The former peaks in April 2009 and, to my surprise, vaccine actually declines over the following two months.