Google Tag Manager triggers: every trigger type explained (2026 guide)

A trigger in Google Tag Manager is the rule that tells a tag when to fire. It listens for an event on the page, such as a page load, a click, a form submission or a custom event pushed to the data layer, and fires the tag when that event happens and the trigger’s conditions are true. Every tag needs at least one trigger, and a web container offers 16 trigger types, grouped into Page View, Click, User Engagement and Other.
Want your tags firing on the right events, and only those? I set up and audit Tag Manager containers for businesses that run ads. Get in touch about a Tag Manager setup.
This guide replaces two older posts of mine (one on what triggers are, one on the trigger types) with one complete, current reference. If you’re new to Tag Manager, start with what Google Tag Manager is and what it’s used for.
How triggers work
Tag Manager works on events. When the container loads, it starts reading a list called the data layer (window.dataLayer). Tag Manager pushes its own events into it as the page loads (gtm.js when the container loads, gtm.dom when the page’s HTML is ready, gtm.load when everything has loaded), and its listeners push more events when a visitor clicks, submits a form, scrolls or watches a video. Your own site can push events too:
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({ event: 'generate_lead', form_name: 'quote' });
Tag Manager processes these messages one at a time, first in, first out. For each event, it checks every trigger in the published container:
- Does the trigger’s type match this event? A Just Links trigger only reacts to link clicks; a Scroll Depth trigger only to scroll thresholds.
- Do its conditions match? By default a trigger fires on all events of its type. You can narrow it with filters, such as “Page Path equals /contact/”.
- Does an exception block it? If the tag also has a blocking trigger that matches, the tag doesn’t fire.
Firing triggers and blocking triggers (exceptions)
A tag has two lists in its Triggering section:
- Firing triggers tell the tag when to fire. If a tag has several, it fires when any one of them matches. A tag with “All Pages” and “Contact page” triggers fires on every page, because All Pages already covers the contact page.
- Exceptions (blocking triggers) stop the tag under certain conditions, even when a firing trigger matches. A classic example: a tag fires on all pages, with an exception for
/thank-you/, so it never fires on the thank-you page.
An exception works best when it reacts to the same event as the firing trigger. A Page View exception can block a Page View firing trigger, but it won’t reliably block a tag fired by a click, because the click is a different event. If you need to block a click tag on certain pages, build the exception as a Click trigger with a Page Path condition, or simply put the page condition into the firing trigger itself.
To add either, open the tag, click Triggering, and use Add under Firing Triggers or Exceptions. You can also create triggers on their own in Triggers → New → Trigger Configuration.
Every trigger type at a glance
These are the trigger types in a web container’s Trigger Configuration menu, grouped the way Tag Manager groups them:
| Group | Trigger type | Fires when | Typical use |
|---|---|---|---|
| Page View | Consent Initialization | Before every other trigger | Cookie banner (CMP) tag, default consent |
| Page View | Initialization | Before all others except Consent Initialization | The Google tag, tags that must run early |
| Page View | Page View | As soon as the page starts loading (gtm.js) | Most page-level tags |
| Page View | DOM Ready | After the HTML is parsed (gtm.dom) | Tags that read page elements |
| Page View | Window Loaded | After the page, images and scripts have loaded (gtm.load) | Non-urgent tags, heavy scripts |
| Click | All Elements | A click on any element | Buttons, images, elements that aren’t links |
| Click | Just Links | A click on an <a> link | Phone, email, outbound and download links |
| User Engagement | Element Visibility | An element appears on screen | “Thank you” messages, banners seen |
| User Engagement | Form Submission | A form’s submit event | Forms that send a real submit event |
| User Engagement | Scroll Depth | A scroll threshold is reached | Reading depth on long pages |
| User Engagement | YouTube Video | Embedded YouTube video start, progress, pause, complete | Video engagement |
| Other | Custom Event | A named event is pushed to the data layer | Leads, purchases, anything the developer pushes |
| Other | History Change | The URL fragment changes or the site uses pushState | Single-page apps |
| Other | JavaScript Error | An uncaught JavaScript error | Error monitoring |
| Other | Timer | Every N milliseconds | Time-on-page events |
| Other | Trigger Group | All of its selected triggers have fired at least once | “Scrolled 50% and stayed 30 seconds” |
Page View triggers
All five fire once per page load, in this order: Consent Initialization → Initialization → Page View → DOM Ready → Window Loaded. Every web container comes with two of them ready-made: Consent Initialization - All Pages and Initialization - All Pages. The familiar All Pages trigger is a Page View trigger with no conditions.
- Consent Initialization is for your consent management platform (cookie banner) tag and the default consent state. It exists so consent is set before any other tag runs. If you serve visitors in the European Economic Area, this is where Consent Mode v2 starts; see Consent Mode v2: how to set it up with Google Tag Manager.
- Initialization is for tags that must run before everything else, above all the Google tag. I walk through that in how to install GA4 with Google Tag Manager.
- Page View fires as soon as the browser starts loading the page. Use it when all you need is the page impression (Page URL, Page Path, Referrer).
- DOM Ready fires after the browser has built the page’s HTML. Use it when a tag or variable reads something on the page, such as a price or a product name from an element.
- Window Loaded fires after the whole page has loaded, images and scripts included. Use it for tags that aren’t urgent, so they don’t compete with the page itself.
To limit any of them to some pages, choose Some Page Views (or the equivalent) and add a condition such as Page Path equals /thank-you/.
Click triggers
- All Elements fires on a click on anything: a button, an image, a
<div>, a link. - Just Links fires only on clicks on HTML links (
<a>elements). It has two extra options: Wait for Tags, which holds the link’s navigation until your tags have fired or a timeout passes, and Check Validation, which fires the tags only for clicks that count as a valid link action (so a link another script cancels won’t count).
Clicks populate the Click built-in variables: Click Element, Click Classes, Click ID, Click Target, Click URL and Click Text. A typical phone-call tracking trigger is Just Links → Some Link Clicks → Click URL starts with tel:. For a full worked example, see how to track every click on your menu items with Tag Manager and GA4.
Google recommends choosing Some Clicks and adding conditions rather than listening to every click, so the trigger only does work where you need it.
User Engagement triggers
Element Visibility
Fires when an element comes into view. You select it by ID or CSS Selector, and choose when to fire: Once per page, Once per element, or Every time an element appears on-screen. Advanced options: Minimum Percent Visible (50% by default), Set minimum on-screen duration, and Observe DOM changes, which you need when the element is added after the page loads, like the “Thanks, we’ll be in touch” message many forms show without changing the URL. Built-in variables: Percent Visible and On-Screen Duration.
This is my usual fallback for lead forms that don’t send a clean submit event.
Form Submission
Fires when a form sends a submit event. Options: Wait for Tags (delay the submission until tags fire or a timeout passes) and Check Validation (fire only when the form was actually sent, rather than on every attempt). Built-in variables: Form Element, Form Classes, Form ID, Form Target, Form URL and Form Text.
The catch: many modern forms (AJAX forms, embedded forms in iframes, page builders) never fire a standard submit event, or fire it even when validation fails. Always test it on the real form. If it doesn’t work, ask the developer for a data layer event on success, or use Element Visibility on the success message.
Scroll Depth
Fires when a visitor scrolls past thresholds you set, Vertical and/or Horizontal, in percentages or pixels (comma-separated). Each threshold fires once per page; a threshold already visible on load fires without any scrolling. You choose when the listener starts: Container Load, DOM Ready or Window Load (the default, and the recommended one, because it measures the page once it’s loaded). Built-in variables: Scroll Depth Threshold, Scroll Depth Units and Scroll Direction. On infinite-scroll pages, Google suggests Element Visibility instead.
Note that GA4’s enhanced measurement already sends a scroll event at 90%. Only build a Scroll Depth trigger if you need other thresholds.
YouTube Video
Fires on interactions with embedded YouTube videos: Start, Complete, Pause, Seeking, and Buffering, and Progress at percentages or times you set. The advanced option Add JavaScript API support to all YouTube videos adds enablejsapi=1 to the player so Tag Manager can listen to it (a playing video can reload when it’s added). Built-in variables include Video Title, Video URL, Video Status, Video Percent, Video Current Time, Video Duration, Video Provider and Video Visible.
Other triggers
Custom Event
Fires when your site pushes an event with that name to the data layer, like the generate_lead example above. Type the event name exactly as the developer pushes it (it is case-sensitive), or tick Use regex matching to match several names. This is the most reliable trigger there is, because the site tells Tag Manager exactly what happened instead of Tag Manager guessing from clicks and forms. For leads and purchases, it’s what I ask developers for first.
History Change
Fires when the URL fragment (the part after #) changes or the site uses the browser’s pushState to change the URL without loading a new page, as single-page apps do. Built-in variables: History Source, Old and New History Fragment, Old and New History State. Check first whether GA4’s enhanced measurement already counts these as page views (“Page changes based on browser history events”), or you’ll count them twice.
JavaScript Error
Fires on uncaught JavaScript errors on the page. Built-in variables: Error Message, Error URL and Error Line. Errors from scripts on another domain usually show only as “Script error.” with no detail, because browsers hide them.
Timer
Fires every set Interval in milliseconds (5000 = every 5 seconds), up to an optional Limit; with no limit it keeps firing until the visitor leaves the page. The event name defaults to gtm.timer. You must set enabling conditions (for example, Page Path matches the pages you want), so the timer only runs where it’s needed. A very short interval with no limit is a performance problem, so keep both sensible.
Trigger Group
Fires once all the triggers you select have fired at least once on the page. Use it for “and” logic across different events, such as scrolled 50% and spent 30 seconds (a Scroll Depth trigger plus a Timer trigger). If you add the same trigger twice, it has to fire twice before the group fires.
Conditions and built-in variables
A trigger condition has three parts: a variable, an operator and a value. For example: Page Path · equals · /contact/. Operators include equals, contains, starts with, ends with, matches RegEx, matches CSS selector, less than and greater than, plus “does not” versions of most of them. Several conditions in one trigger must all be true.
Conditions mostly use built-in variables, which you switch on in Variables → Configure (under Built-In Variables). If Click Text or Form ID isn’t in the condition dropdown, it isn’t enabled yet. The useful groups for web containers:
- Pages: Page URL, Page Hostname, Page Path, Referrer
- Utilities: Event, Container ID, Container Version, Environment Name, Random Number, HTML ID, and the Analytics Client ID, Session ID and Session Number variables
- Clicks: Click Element, Click Classes, Click ID, Click Target, Click URL, Click Text
- Forms: Form Element, Form Classes, Form ID, Form Target, Form URL, Form Text
- History, Videos, Scroll, Visibility and Errors: the variables listed under each trigger above
For anything not covered, create a user-defined variable (Variables → New), for example a Data Layer Variable to read form_name from the push above.
Trigger order and tag order
Two things decide what runs first:
- Events happen in order. On every page, the Page View family runs in its fixed sequence, and interaction events come after. That’s why the Google tag goes on Initialization: it has loaded before your event tags fire on Page View, clicks or custom events.
- Within one event, tags fire together. If one tag must run before another on the same event, use Tag firing priority (higher numbers fire first) or Tag Sequencing (fire a setup tag before, or a cleanup tag after), both under the tag’s Advanced Settings. Priority only controls the start order; sequencing waits for the setup tag to finish. When tag sequencing fires a tag, that tag ignores its own triggers.
How to test triggers in Preview mode (Tag Assistant)
- In your workspace, click Preview. Tag Assistant opens in a new tab.
- Enter your site’s address and click Connect. The site opens in a new window, connected to Tag Assistant.
- Back in Tag Assistant, the left column lists every event on the page in order: Consent Initialization, Initialization, Container Loaded, DOM Ready, Window Loaded, then each click, form submission or custom event you cause.
- Click an event. Tags Fired and Tags Not Fired show what happened on that event.
- Click a tag that didn’t fire. Tag Assistant shows its firing triggers and each condition with a check or a cross, so you can see which one failed.
- Open the Variables tab on the same event to see the values Tag Manager saw, such as the Click URL or Form ID, and the Data Layer tab to see exactly what was pushed.
If the site breaks in preview, untick Include debug signal in the URL before connecting. Nothing you do in Preview reaches real visitors until you publish.
Common mistakes I see
- The built-in variable isn’t enabled. Someone builds a click trigger on “Click Text contains Call” and it never fires, because Click Text was never switched on. Enable it in Variables → Configure.
- Click triggers on the wrong element. People click an icon or a
<span>inside the button, so Click Text and Click URL come back empty. Test in Preview, look at what Click Element actually is, and use matches CSS selector with a descendant selector (for examplea[href^="tel:"], a[href^="tel:"] *) when needed. - Form Submission on forms that never submit. It fires on every attempt, or never, on AJAX and embedded forms. In the accounts I audit, this is one of the most common reasons Google Ads shows more (or fewer) leads than the CRM. Use a data layer event or Element Visibility on the success message.
- Exceptions built on the wrong event. A Page View exception attached to a click-fired tag doesn’t block it. Match the event type, or move the condition into the firing trigger.
- Duplicate events with GA4 enhanced measurement. Scroll Depth, form and outbound link triggers sending events that enhanced measurement already sends. Pick one source per event.
- Thank-you page triggers that also match other pages. “Page URL contains thank” also matches a blog post titled “Thank you for…”. Use Page Path equals the exact path.
- Everything on All Pages. Third-party tags with no conditions fire on every page, including pages where they do nothing but slow the site down.
- Previewed but never published. It works in Preview, nobody clicks Submit, and the tag never fires for real visitors.
FAQ
What is a trigger in Google Tag Manager?
It’s the rule that decides when a tag fires. A trigger listens for an event (a page load, a click, a form submission, a data layer event) and fires its tags when the event happens and its conditions are true. A tag can’t be saved without at least one trigger.
What’s the difference between All Pages and Initialization - All Pages?
Both fire on every page, but Initialization fires earlier, before every Page View trigger. Google recommends Initialization - All Pages for the Google tag, Consent Initialization - All Pages for your cookie banner, and All Pages or narrower triggers for everything else.
Can a tag have more than one trigger?
Yes. It fires when any one of its firing triggers matches. If you need two things to happen before a tag fires (“and” rather than “or”), use a Trigger Group.
What is a trigger exception?
A blocking trigger added under Exceptions in a tag. When it matches, the tag doesn’t fire, even if a firing trigger matches too. Build the exception on the same event type as the firing trigger.
Why doesn’t my trigger fire?
Check in Preview: is the event in the left column at all; is the built-in variable enabled; does each condition show a check; is an exception blocking it; and is the change published? Most failures are a variable that isn’t enabled or a condition that doesn’t match the real value.
Need help with your Tag Manager triggers?
Triggers are where most tracking quietly goes wrong: tags fire twice, fire on the wrong page, or never fire on the form that matters. I build and audit Tag Manager containers so every lead and sale is counted once, in GA4 and in Google Ads. Ask me for a conversion tracking review.

