{"id":137242,"date":"2025-03-16T11:22:38","date_gmt":"2025-03-16T11:22:38","guid":{"rendered":"https:\/\/peraltafinancing.com\/analytics\/firing-a-single-tag-multiple-times-in-gtm\/"},"modified":"2025-03-16T11:22:38","modified_gmt":"2025-03-16T11:22:38","slug":"firing-a-single-tag-multiple-times-in-gtm","status":"publish","type":"post","link":"https:\/\/fivemor.com\/?p=137242","title":{"rendered":"Firing A Single Tag Multiple Times In GTM"},"content":{"rendered":"


\n<\/p>\n

\n

There might be many reasons you\u2019d want to fire a single Tag multiple times in Google Tag Manager<\/a>. 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.<\/p>\n

Quite a while ago, I gave a solution for this<\/a> with a specific focus on Google Analytics<\/a> Tags. It leveraged the hitCallback<\/a> feature of the Universal Analytics library by increasing a global counter each time a Tag had fired. This solution had a number of drawbacks: being GA-specific, polluting the global namespace, and requiring a unique setup for every single Tag you wanted to fire.<\/p>\n

Not long after this, I actually started doing the whole thing in a different way. A much more durable, sensible, robust way, and in this article I want to open up the method. In fact, it\u2019s not just me<\/em> who wants to introduce this. This article is a collaboration with Marco Wekking from Adwise<\/a>. He approached me with almost exactly the same solution asking for a review. Instead of reviewing, I asked if he would like to contribute to a collaboration of sorts on this post, and he gracefully accepted. So, much of this post is from Marco\u2019s pen, with my typical bad humour and some JavaScript shenanigans intertwined in the rhetoric.<\/p>\n


\n X<\/span><\/p>\n

\n
\n The Simmer Newsletter<\/strong>\n <\/p>\n

\n Subscribe to the Simmer newsletter<\/a> to get the latest news and content from Simo Ahava into your email inbox!\n <\/p>\n

<\/span><\/p>\n

How it works<\/h2>\n
\n

<\/p>\n

\"Fire<\/p>\n

<\/a><\/p>\n<\/div>\n

The skilfully grafted diagram above shows how the solution works. Every single event that passes through dataLayer<\/code> is duplicated by suffixing it with .first<\/code> and .second<\/code>. This way, all the Tags you want to fire twice per event just need to be modified to use the original event name plus the two suffixes. You can even use this in a Lookup Table to fire the hits to different Google Analytics tracking properties, for example.<\/p>\n

It\u2019s a simple, elegant solution to a pressing problem which, if you ask me, should be handled natively by the platform. This is such a common use case for so many people – it would be immensely helpful if you could just denote multiple cycles to each Tag using the Tag template settings instead of having to resort to hacks like this.<\/p>\n

How to do it<\/h2>\n

The solution comprises three steps:<\/p>\n

    \n
  1. \n

    Create a new Custom Event Trigger<\/p>\n<\/li>\n

  2. \n

    Create the Custom HTML Tag which manages the duplication<\/p>\n<\/li>\n

  3. \n

    Create new Triggers<\/p>\n<\/li>\n<\/ol>\n

    We\u2019ll wrap it up with an example of how to leverage this when firing to multiple Google Analytics properties! So stay tuned.<\/p>\n

    1. Create the Custom Event Trigger<\/h2>\n

    To fire the Custom HTML Tag, we\u2019ll need a Trigger which activates on every single event<\/em>. Why? Because we want to duplicate every single event! There\u2019s just one exception – we don\u2019t want to fire the Trigger when the actual duplication events are pushed into dataLayer<\/code>, or we might find ourselves in an infinite loop. Ontologically fascinating, but not cool when it comes to site performance.<\/p>\n

    Before you create the Trigger, make sure you have the Event<\/strong> Built-in Variable checked in the appropriate slot of the Variables page in your container.<\/p>\n

    \n

    <\/p>\n

    \"Event<\/p>\n

    <\/a><\/p>\n<\/div>\n

    This is required for the Trigger to work.<\/p>\n

    Next, create a Trigger which matches all events except for the duplicated ones. In this example, we\u2019re using the generic .first<\/code> and .second<\/code> as the suffixes, but nothing\u2019s stopping you from using something more descriptive, for example .Country<\/code> and .Rollup<\/code>.<\/p>\n

    \n

    <\/p>\n

    \"Non-duplicate<\/p>\n

    <\/a><\/p>\n<\/div>\n

    To reiterate: The exception is important<\/strong>! If you don\u2019t add that Fire On condition, you will run into issues, as the Trigger would fire again and again with each duplication cycle. Yes, you could use the Tag Firing Options<\/a> feature of the Tag templates, but it\u2019s better to nip bad behavior in its bud.<\/p>\n

    2. Create the Custom HTML Tag<\/h2>\n

    The Custom HTML Tag is the heart and soul of this solution. It\u2019s very simple, but it does have some peculiarities that might surprise if you\u2019re not familiar with how GTM works.<\/p>\n

    Actually, to ensure that one of these special features works as it should, you\u2019ll need to activate yet another Built-In Variable: Container ID. This returns, surprise surprise, the public ID of the GTM container the Tag is firing in (GTM-XXXX).<\/p>\n

    \n

    <\/p>\n

    \"Container<\/p>\n

    <\/a><\/p>\n<\/div>\n

    Create a new Custom HTML Tag and add the following code within:<\/p>\n

    \n
    script>\n  (function<\/span>() {\n    var<\/span> event = {{Event}};\n    var<\/span> gtm = google_tag_manager[{{Container ID}}];\n\n    window<\/span>.dataLayer.push({\n      'event'<\/span> : event + '.first'<\/span>\n    });\n    window<\/span>.dataLayer.push({\n      'event'<\/span> : event + '.second'<\/span>,\n      'eventCallback'<\/span> : function<\/span>() { gtm.onHtmlSuccess(); }\n    });\n  })();\nscript<\/span>><\/code><\/pre>\n<\/div>\n
    Finally, we\u2019re doing two<\/strong> consecutive dataLayer.push()<\/code> commands, one for each iteration of the cycle. If you want to add more events there, be my guest. As far as we know, there is no limitation to the number of events you can push into dataLayer<\/code> this way.<\/p>\n
    The latter push includes the special eventCallback<\/code> key (read more about it here<\/a>). The key holds a callback function which is invoked as soon as Tags which fire on this particular push have signalled their<\/em> completion. Within this callback, we\u2019re using the onHtmlSuccess()<\/code> feature of GTM\u2019s interface. This is something that was exposed for public use with the Tag sequencing<\/a> feature. The only thing you need to know about it is that it\u2019s our way of telling GTM that it can now proceed with whatever was going on before this loop of dataLayer.push()<\/code> commands.<\/p>\n
    In other words, if you\u2019re duplicating a Click \/ Just Links<\/strong>, and you\u2019ve got \u201cWait for Tags\u201d checked (meaning the Trigger will wait for all dependent Tags to fire before proceeding with the link default action), the process goes something like this:<\/p>\n
      \n
    1. \n
      The link click Trigger fires this Custom HTML Tag.<\/p>\n<\/li>\n
    2. \n
      The Custom HTML Tag pushes the first duplicated event, and any Tags which use it start their execution.<\/p>\n<\/li>\n
    3. \n
      Immediately after, the Custom HTML Tag pushes the second duplicated event, and any Tags which use it start their execution.<\/p>\n<\/li>\n
    4. \n
      Once the last Tag firing on the second duplicated push signals its completion, the eventCallback<\/code> callback is invoked, and the Custom HTML Tag tells the link click Trigger that everything is done, allowing it to proceed with the redirect.<\/p>\n<\/li>\n<\/ol>\n
      Now, add the Trigger you created in the previous step to this Tag, and you\u2019re ready to duplicate. You can preview this to see what happens in your dataLayer with each event.<\/p>\n
      \n
          <\/p>\n
          \"Preview<\/p>\n
          <\/a><\/p>\n<\/div>\n
      As you can see, each event is duplicated. There\u2019s the Pageview<\/strong>, followed by its duplicates: gtm.js.first<\/strong> and gtm.js.second<\/strong>. There\u2019s DOM Ready<\/strong>, followed by its duplicates: gtm.dom.first<\/strong> and gtm.dom.second<\/strong>, and so on.<\/p>\n
      (If you don\u2019t understand what \u201cPageview\u201d and \u201cgtm.js\u201d have to do with each other, the latter is the underlying event representation of the former. More information in my Trigger guide<\/a>.)<\/p>\n
      3. Create new Triggers<\/h2>\n
      The only housekeeping pain you\u2019ll need with this solution is with the Triggers. Here\u2019s how it should work:<\/p>\n
    We\u2019re wrapping the whole thing in an IIFE<\/a> as we want to avoid polluting the global namespace. Next, we\u2019re assigning a local variable event<\/code> with whatever value is currently stored in the Built-in Event<\/strong> variable (i.e. the event that was pushed in the first place).<\/p>\n