GTM Ad Tags: 4 Steps to Video Analytics in 2026

To get video ad campaigns right, you need tracking that’s just as precise, and Google Tag Manager (GTM) is the best tool for centralizing that whole setup. When you deploy ad tags through GTM, you move faster, stop waiting on developers for every little change, and get consistent data no matter where the video plays. This isn’t just about making your life easier. It’s about having numbers you can trust in a marketing environment that changes by the minute. So how do you actually get GTM to fire those video ad tags when they’re supposed to?

1. Implement a Strong Data Layer for Video Events

Any decent video tracking setup in GTM starts with a well-planned Data Layer. It’s the communication bridge between your website and GTM. For video, you have to push information about what a user is doing with your video player directly into this Data Layer. If you don’t, GTM is flying blind and has no idea when to fire your video-related tags.

For example, when someone hits play, your site’s code should fire an event like video_play along with the details. A standard dataLayer push for a play event should look something like this:

<script> window.dataLayer = window.dataLayer || []. DataLayer.push({ 'event': 'video_play', 'video_player_name': 'YouTube Embedded Player', 'video_title': 'Product Demo 2026', 'video_id': 'xyz123abc', 'video_status': 'play', 'video_percent_watched': 0 });
</script>

You’ll need to get your dev team to implement these pushes for the main interactions: play, pause, seek, and especially completion. Make sure you capture video_title and video_player_name. These are the dimensions you’ll need to segment performance later in GA4 or whatever analytics tool you’re using. With the 2023 IAB Digital Video Ad Spend Report showing continued growth in video ad spend, being able to show granular ROI is non-negotiable.

Pro Tip: Standardize your event names and variable keys. If you use ‘video_play’ for YouTube, use it for Vimeo too. This kind of consistency makes GTM configuration way easier and prevents a ton of hard-to-find errors, especially if you’re juggling multiple video platforms.

2. Configure Custom Variables for Data Layer Information

Once the data is flowing into the Data Layer, you need to teach GTM how to read it. You do this with Data Layer Variables. Inside your GTM container, just go to “Variables,” then find “User-Defined Variables,” and create a new “Data Layer Variable” for every piece of data you’re pushing from the site.

Using the example from before, you’d set up variables like these:

• dlv - video_player_name (Data Layer Variable Name: video_player_name)
• dlv - video_title (Data Layer Variable Name: video_title)
• dlv - video_id (Data Layer Variable Name: video_id)
• dlv - video_status (Data Layer Variable Name: video_status)
• dlv - video_percent_watched (Data Layer Variable Name: video_percent_watched)

The “Data Layer Variable Name” field has to be an exact match for the key in your dataLayer.push(). Case sensitivity is a killer here. I’ve seen entire tracking projects fail because of a simple capitalization typo between the code and the GTM variable name.

Common Mistake: Not setting a default value for your variables. It’s not always required, but setting a default can stop your tags from throwing errors if a variable isn’t available in a specific dataLayer push. GTM will just use your default value instead of returning an `undefined` that could break a script.

3. Create Custom Event Triggers for Specific Video Actions

With your variables configured to read the data, you now create Custom Event Triggers to act on it. These triggers are set up to listen for the specific event names you defined in your Data Layer pushes, like video_play, video_pause, or video_complete.

Head over to “Triggers,” click “New,” and pick “Custom Event” as the trigger type. In the “Event Name” box, type in video_play. You can get more specific here by adding conditions, for instance, if you only want the trigger to fire on certain videos by using a condition like “dlv - video_player_name equals YouTube Embedded Player.”

You’ll need to repeat this for your other events like video_pause and video_complete. If you’re tracking progress, you’d also create one for video_progress. Tracking video completion is especially useful for understanding engagement on longer videos or critical product demos.

4. Use GTM’s Built-in YouTube Video Triggers

If you’re embedding YouTube videos, GTM gives you a very handy, pre-built “YouTube Video” trigger. This can save you from having to set up custom Data Layer pushes for basic events, which really simplifies the initial setup.

• Start
• Pause, Seeking, Buffering
• Progress (e.g., at 25%, 50%, 75%, 100% of video watched)
• Complete

To get this working, you first have to go into the “Variables” section and enable the “Built-In Variables” for “Video.” After that’s done, create a new trigger, choose “YouTube Video,” and just check the boxes for the events you want to track. A key step here is to look under “Advanced Settings” and check “Enable JavaScript API Support for all YouTube Videos,” especially if your site’s YouTube embeds don’t already have the enablejsapi=1 parameter in the URL.

I find the “Progress” option here is incredibly useful. Setting triggers for 25%, 50%, 75%, and 100% gives you a fantastic view of viewer retention and drop-off points without needing to write any complex code. It lets you see the difference between someone who just clicked by accident and someone who’s actually watching.

Pro Tip: When you’re using the built-in YouTube trigger, don’t forget to also enable GTM’s built-in video variables (like Video Status, Video Title, etc.). This lets you capture all that useful context for your tags without any extra dataLayer work.

5. Create and Configure Your Ad Tags

Now that the plumbing is in place with your triggers and variables, you can finally build the ad tags themselves. The most common tags for video campaigns are Google Ads conversion trackers, Google Analytics 4 (GA4) event tags, or pixels for other ad platforms.

Example: Google Ads Conversion Tag for Video Completion

1. Go to “Tags” and hit “New.”
2. Pick “Google Ads Conversion Tracking” for the tag type.
3. Paste in your Conversion ID and Conversion Label from your Google Ads account.
4. For the “Triggering” section, just select the “video_complete” Custom Event Trigger you already made (or the 100% YouTube Video Trigger).

Example: GA4 Event Tag for Video Play

1. Go to “Tags” and click “New.”
2. Choose “Google Analytics: GA4 Event” as the tag type.
3. Select your main GA4 Configuration Tag.
4. Give it a clear “Event Name,” like video_interaction.
5. This is the important part: under “Event Parameters,” add rows to pass along the data from your Data Layer variables. For example:
   • video_player with value {{dlv - video_player_name}}
   • video_title with value {{dlv - video_title}}
   • video_status with value {{dlv - video_status}}
   • video_percent with value {{dlv - video_percent_watched}}
6. Under “Triggering,” choose your “video_play” Custom Event Trigger.

What parameters you send to GA4 is up to you, but sending the player name, video title, and interaction status gives you a rich dataset for later analysis. A recent eMarketer report confirms that marketers are no longer satisfied with simple view counts and are demanding deeper engagement metrics.

6. Test Your Video Ad Tags Thoroughly

This is the most important step, and the one people always rush. Never, ever publish a GTM container without testing it first. Use GTM’s Preview mode to make sure your tags fire exactly when you expect them to.

1. Click the “Preview” button in your GTM workspace.
2. Enter your site’s URL and hit connect.
3. Go to the page that has your video on it.
4. Start playing the video, pause it, scrub through it, and let it finish.
5. Watch the “Tag Assistant” debugger window like a hawk.

In the debugger, look at the event list on the left. When you play the video, you should see your custom event name (like video_play) or the built-in “YouTube Video” event appear. Click on that event. The main window will show you which tags fired, but more importantly, it will show you the data that was passed through your variables. You have to confirm that the values for video_title and other parameters are showing up correctly.

You should also open your browser’s developer tools (F12) and inspect the Network tab. You’re looking for the actual network requests being sent to Google Ads or GA4. For GA4, you can find the request to a URL containing /g/collect or /j/collect and verify the event name and parameters being sent are correct.

Common Mistake: Only looking at Preview mode. It’s a great debugger, but you should always confirm the network requests are actually being sent with the right data. I’ve seen tags that look fine in Preview mode get blocked on the live site by a consent script or some other issue, and no data is ever sent.

7. Publish Your GTM Container

After you’ve tested everything and you’re confident all your tags are firing correctly with the right data, it’s time to publish. Click the “Submit” button in GTM, give your version a name that you’ll understand in six months (like “Added Video Completion Tracking for Product Demos”), and hit publish.

Even after publishing, I always do a quick check on the live site just to be sure nothing broke. Then, keep an eye on your analytics dashboards for the next day or two to confirm that the video data is coming in as you expect. This final check can save you from realizing a week later that a small issue slipped through testing.

Using GTM for video ad tags gives you an incredible amount of control. If you take the time to structure your Data Layer, set up your variables and triggers correctly, and then test everything, you’ll end up with performance data that’s both accurate and genuinely useful. This is how you make smart decisions to optimize your ad spend and improve how your campaigns perform, which is especially important if you’re trying to refine how your AI algorithms mastering video ads are working.