A recent update to Google Tag Manager<\/a> introduced a feature which has been on the wishlist of many users for a long time. It\u2019s called Tag sequencing<\/strong>, and its purpose is to facilitate the sequential firing of Tags. The idea is that you can specify a setup<\/strong> and a cleanup<\/strong> for each Tag in your container.<\/p>\n <\/p>\n <\/a><\/p>\n<\/div>\n This article is intended to function as a quick tour of the feature. It\u2019s not the simplest feature to understand, as Tag sequencing runs parallel but separate from the normal flow of your container. Don\u2019t worry, I\u2019ll get back to this soon.<\/p>\n \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 A sequence<\/em> comprises three phases:<\/p>\n The setup<\/strong>, which is a Tag which must successfully<\/em> complete before the main Tag fires.<\/p>\n The main tag<\/strong>, which is the Tag with the dependencies. It\u2019s either dependent on the setup<\/strong>, or it establishes a dependency with the cleanup<\/strong>.<\/p>\n The cleanup<\/strong>, which is a Tag which fires after the main tag<\/strong> has completed successfully.<\/p>\n <\/p>\n <\/a><\/p>\n<\/div>\n The sequence is created by editing the Advanced Settings<\/strong> of the main tag<\/strong>. You will see two new settings here:<\/p>\n Fire a tag before\u2026<\/p>\n<\/li>\n Fire a tag after\u2026<\/p>\n<\/li>\n<\/ul>\n The first setting is for choosing the setup<\/strong> for the main Tag<\/strong>. The latter is for the cleanup<\/strong>. If you choose a setup<\/strong>, it will need to complete before the main tag<\/strong> itself fires. If you choose a cleanup<\/strong>, the main tag<\/strong> will need to complete before the teardown<\/strong> is fired. For both, you can choose whether or not a failure in either the setup<\/strong> or the main tag<\/strong> will abort the sequence.<\/p>\n OK. That was confusing. Allow me to visualize it with my superior PowerPoint skills.<\/p>\n <\/p>\n <\/a><\/p>\n<\/div>\n In the sequence above, the Page View Tag (setup<\/strong>) must successfully complete before the Event Tag (main tag<\/strong>) fires. If the Page View Tag fails, the sequence is aborted. Similarly, the Event Tag must successfully complete before the final Event Tag (cleanup<\/strong>) fires. If the main Tag fails, the final Event Tag will not fire.<\/p>\n You can, of course, specify that the Tags fire even if some member in the sequence fails.<\/p>\n The key thing to understand about the sequence is that it\u2019s isolated<\/em>. Using Tag sequencing lets you specify a sequence of hits that fire when the main tag<\/strong> is triggered. This means that the setup<\/strong> and cleanup<\/strong> Tags will act completely oblivious to any Triggers you might have added to them.<\/p>\n Indeed, no matter what Triggers you have or have not equipped on them, they are completely ignored if the Tag is used as a setup<\/strong> or cleanup<\/strong>. For this reason, it might be prudent to not<\/em> use setup<\/strong> and cleanup<\/strong> Tags for anything except sequencing, but there is a way to make it work both ways (I\u2019ll get back to this soon).<\/p>\n I emphasize again that this is a difficult concept to grasp. I\u2019m sure the UX \/ UI could be made more intuitive, but the reason it\u2019s difficult is that it relies on callbacks, which are invisible in actual GTM usage (unless you start debugging on a really granular level).<\/p>\n We still have some theory to cover before delving deeper into the practical stuff.<\/p>\n In GTM, each Tag has a callback. With Tag templates, these callbacks depend on how the Tag works. For example, the Google Analytics Tag uses the hitCallback<\/a> feature as its callback.<\/p>\n So, when you establish a setup<\/strong>, for example, the main tag<\/strong> will not fire until the Phew!<\/p>\n The other callback is You don\u2019t have to worry about these callbacks when using Tag templates. GTM takes care of calling The exception is the Custom HTML Tag<\/strong>. Since you might want to tell Google Tag Manager not to proceed to the next tag until something has happened (e.g. an asynchronous operation has completed), a workaround is required. If you go to the Built-in Variables<\/strong>, you should see a new one: HTML ID<\/strong>:<\/p>\n <\/p>\n <\/a><\/p>\n<\/div>\n This is used to invoke either the So, if you want to use a Custom HTML Tag as either the setup<\/strong> or the main tag<\/strong>, and you want to establish a sequence with success and\/or failure conditions, you will need the following:<\/p>\n The HTML ID<\/strong> Built-In Variable<\/p>\n<\/li>\n The Container ID<\/strong> Built-In Variable<\/p>\n<\/li>\n The Custom HTML Tag<\/strong> itself<\/p>\n<\/li>\n<\/ol>\n In the following code example, I\u2019m running some custom JavaScript, and once it\u2019s done, I\u2019m letting the sequence know that In the first line of the script, you copy a reference to the GTM container interface into the Next, there\u2019s a If there\u2019s an error, then the By now it shouldn\u2019t be too complicated anymore to understand what\u2019s happening. Each Tag template has an UPDATE 23 July 2018<\/strong>: Be sure to read my article on Custom HTML tags with tag sequencing<\/a> for more details on how Custom HTML tags and tag sequencing work together.<\/p>\n<\/blockquote>\n Finally! Some practical information!<\/p>\n Under the Advanced Settings<\/strong> of each Tag template, you will find three new options:<\/p>\n Tag firing options<\/strong> – Lets you delimit the Tag to fire either just Once per event<\/em>, Once per page<\/em>, or just let it fire Unlimited<\/em> times.<\/p>\n<\/li>\n Tag Sequencing -> SETUP<\/strong> – Lets you choose the Tag which must complete before the Tag whose settings you are currently editing. You can specify whether the setup<\/strong> must complete successfully, or if failures should still make this Tag fire.<\/p>\n<\/li>\n Tag Sequencing -> CLEANUP<\/strong> – Lets you choose the Tag which must fire after the current Tag has completed execution. Again, you can specify whether the current Tag must complete successfully, or if its failure should be ignored, and the cleanup<\/strong> should fire regardless.<\/p>\n<\/li>\n<\/ol>\n <\/p>\n <\/a><\/p>\n<\/div>\n That\u2019s how you set up a Tag Sequence<\/strong>.<\/p>\n Now, in the very beginning I mentioned that the sequence works in isolation. This means that the setup you establish for any particular Tag will run the sequence regardless of what other Triggers you might have attached to the setup<\/strong> or cleanup<\/strong>. This also means that a sequence is always bound to the event of the main tag<\/strong>. Thus, if the main tag<\/strong> fires upon the \u201cAll Pages\u201d Trigger, for example, then the entire sequence will be completed during this event.<\/p>\n Because you can use a Tag both independently and as part of a sequence, the new Tag firing options<\/strong> are very useful, indeed. For example, if you have Tag A as the setup<\/strong> for some Tag, as well as firing on its own, individual Trigger, you can specify that Tag A must only fire Once per page<\/em> to prevent multiple hits from being sent. This means simply that after it has fired once, either independently or as part of a sequence, it will not fire again while the user is on the page.<\/p>\n You can also specify Once per event<\/em>, which means that the Tag will only fire once for any given data layer event<\/strong>. So, you might have Tag A firing on the \u201cAll Pages\u201d Trigger, and you might also have it as the cleanup<\/strong> of some Tag which also fires on the \u201cAll Pages\u201d Trigger. By using the Once per event<\/em> setting, Tag A will only fire once during the \u201cAll Pages\u201d event.<\/p>\n One of the main use cases for using tag sequencing would be to have the setup<\/strong> Tag push something into Hold your horses!<\/p>\n If you know your Google Tag Manager, you\u2019ll know that the Data Layer available to any Tag is fixed for the duration of the Data Layer Event<\/strong>! So any Tags which fire on the initial (UPDATE:<\/strong> Some time after this article was written, GTM\u2019s behavior changed so that variables are resolved separately for every tag in a sequence. This means that you don\u2019t<\/em> need to use This hampers development a little, since it sounds like The developer guide<\/a> actually has a note about this:<\/p>\n![\"Tag](\"https:\/\/www.simoahava.com\/images\/2015\/05\/tag-sequencing.jpg#ZgotmplZ\")
<\/p>\n
\n X<\/span><\/p>\n
\n The Simmer Newsletter<\/strong>\n <\/p>\n1.Sequence in a nutshell<\/h2>\n
![\"Setup](\"https:\/\/www.simoahava.com\/images\/2015\/08\/setup-cleanup.jpg#ZgotmplZ\")
<\/p>\n\n
![\"tag](\"https:\/\/www.simoahava.com\/images\/2015\/05\/sequence.jpg#ZgotmplZ\")
<\/p>\n2. The callbacks<\/h2>\n
onSuccess<\/code> callback of setup<\/strong> is invoked. With the Google Analytics Tag template, the tag<\/strong> will be fired only after the hitCallback of the setup<\/strong> is executed successfully. Similarly, the cleanup<\/strong> will not be fired until the onSuccess<\/code> callback of the main tag<\/strong> is called.<\/p>\nonFailure<\/code>. This is invoked in case the Tag does not successfully complete. In the settings for Tag sequencing, you can specify that the main tag<\/strong> must not fire if setup<\/strong> fails, or you can choose to ignore the failure. Similarly, you can specify that the cleanup<\/strong> must not fire if main tag<\/strong> fails, or you can, again, choose to ignore the failure.<\/p>\nonSuccess<\/code> and onFailure<\/code> for you, and all you need to do is make sure that you\u2019ve checked the correct boxes in the settings (I promise, we\u2019re going to get to the settings very soon!).<\/p>\n3. The Custom HTML Tag<\/h2>\n
![\"HTML](\"https:\/\/www.simoahava.com\/images\/2015\/05\/html-id.jpg#ZgotmplZ\")
<\/p>\nonSuccess<\/code> or onFailure<\/code> callback for the Custom HTML Tag.<\/p>\n\n
onSuccess<\/code> has been called.<\/p>\nscript>\n (function<\/span>() {\n var<\/span> gtm = window<\/span>.google_tag_manager[{{Container ID}}];\n var<\/span> el = document<\/span>.getElementById('content-head'<\/span>);\n try<\/span> {\n el.innerHTML = 'We have taken over your website!'<\/span>;\n gtm.onHtmlSuccess({{HTML ID}});\n } catch<\/span>(e) {\n gtm.onHtmlFailure({{HTML ID}});\n }\n })();\nscript<\/span>><\/code><\/pre>\n<\/div>\ngtm<\/code> variable. This is a very specific interface into GTM\u2019s mechanisms, so don\u2019t worry about it too much. Suffice to say that this reference allows you to pass the onSuccess<\/code> and onFailure<\/code> callbacks, which is why it\u2019s important here.<\/p>\ntry...catch<\/code> block, where a DOM method is executed. Once it\u2019s completed, the onHtmlSuccess()<\/code> method of the interface is invoked. The parameter to this method is the new HTML ID<\/strong> Built-In Variable. This way GTM will be able to communicate to the next member of the sequence that it was precisely this<\/em> particular Custom HTML Tag that just completed.<\/p>\nonHtmlFailure()<\/code> method is invoked, and information is passed to the sequence that this Tag did not complete successfully.<\/p>\nonSuccess<\/code> and onFailure<\/code> callback, except for the Custom HTML Tag, where you can to provide them yourself.<\/p>\n\n
4. How to create the sequence<\/h2>\n
\n
![\"Tag](\"https:\/\/www.simoahava.com\/images\/2015\/05\/new-settings.jpg#ZgotmplZ\")
<\/p>\n5. Note about using
dataLayer.push()<\/code> in the sequence<\/h2>\ndataLayer<\/code> for the main Tag to use.<\/p>\ndataLayer.push()<\/code> will only be able to access the values in this push. If some Tag tries to modify the values in the Data Layer, these values will not be registered until the next<\/strong> dataLayer.push()<\/code> with an event.<\/p>\ngoogle_tag_manager[...].dataLayer.get()<\/code> if you want to retrieve a variable that changed from one tag in the sequence to the next. Instead, you can just use regular Google Tag Manager Variables, as their values will update for each tag in the sequence!)<\/p>\ndataLayer<\/code> can\u2019t be used as a messaging medium within a sequence, as the entire sequence operates in the span of a single Data Layer Event (the one which fired the main Tag in the first place).<\/p>\n
![\"Tag](\"https:\/\/www.simoahava.com\/images\/2015\/08\/tag-sequencing-help.jpg#ZgotmplZ\")
<\/p>\n