GA4 101: Everything you need to know to get started with Google Analytics 4

Alert! If you only read one thing, read this…

Google has announced that the version of Google Analytics that we’ve been using for the last decade (Universal Analytics) will stop processing new data from July 2023, and will permanently shut down at some point after that. Unfortunately, you cannot transfer or import your website’s data from Universal Analytics into GA4 (Google Analytics 4). So if you haven’t already, set up GA4 on your website to start collecting data from today. This will require new implementation for websites, and data will only be collected from that time forward. If you leave this until after July 2022 this means you’ll have gaps in your data and won’t be able to do year-on-year comparisons.

Google’s latest version of analytics, GA4, has been the talk of the town lately, especially since their recent announcement that they’re permanently shutting down Universal Analytics, signalling to individuals and organisations that they need to make the move. 

The good news is that GA4 has plenty to offer. The platform hasn’t just had a facelift, it’s been totally rebuilt from the ground up, so here’s everything you need to know about getting started with GA4 and how it compares to Universal Analytics.

(Btw, we’ve assumed that readers have some knowledge of Google Analytics. If not, we recommend starting with Google’s help centre.)

But really, WTF is GA4?

GA4 is the 4th iteration and latest version of Google Analytics.

For the first time since the original Google Analytics, Google has rebuilt the platform from the ground up. This isn’t just an ordinary redesign – it’s a totally new product.

This means what you’re used to may have changed, so it’s worth keeping Google’s glossary of dimensions and metrics on hand.

GA4 vs. Universal Analytics, what’s new?

Even though GA4 and Universal Analytics might seem pretty similar on the surface, once you start digging around you’ll quickly notice they are completely different. Here are the new features you can expect. 

A different data model

GA4 uses a new event-based model. This is why your data won’t carry over from Universal Analytics to GA4. Everything is now an event and the capabilities are very different to Universal.

A new, customisable interface

You’ve become used to Universal Analytics’s graph and table of data, but that’s all changing with GA4.

Instead, your data is presented in report cards which, for most reports, have far more data than the tables of old. You’ll still find your navigation on the left, but there are new standard reports. You should also notice that real-time is integrated within your standard reports instead of being its own individual section.

These new layouts are also customisable, with the ability to save your customised interface for all users. All you have to do is click the customise option. 

Everything in one analytics platform

Until now, tracking mobile and app data requires you to integrate Firebase and GA. And even then, it could be difficult to understand how your web and app data actually fit together.

There have been different versions of this over the years. Firstly with Google Analytics, which was primarily for the web and then with Google Analytics for Firebase which was primarily built for apps and uses an entirely different data model and UI. With this version, you could build funnels, unlike in GA. 

GA4 is built off of Firebase’s functionality and so offers seamless app and web tracking. 

With GA4 you can combine streams of data from multiple domains, websites and apps (both iOS and Android) into one single property. This gives you the ability to view, track and manage your websites and apps, all in one place. This is super convenient for those with several websites and mobile apps. 

It’s worth noting that streams are not the same thing as views. GA’s views aren’t currently included in GA4.

New metrics to measure behaviour

When first switching to GA4, you’ll notice that many of the default reports you use have been removed or replaced, including popular dimensions and metrics. 

One example of this is bounce rate. Bounce rate has always been an important yet somewhat problematic metric when measuring the quality of your traffic. This is because it doesn’t account for users who find what they’re looking for (i.e: their queries are met) but don’t take any further actions on your website.

GA4 has now replaced bounce rate with the easier-to-measure engaged sessions. Engaged sessions are when a user has actively interacted with your website or app for at least 10 seconds. 

To calculate your engagement rate: Engagement rate = engaged sessions / sessions.

Another example is that URLs are less important, with screens and page titles being the new, easier way to analyse across websites (desktop and mobile) and apps. URLs and URIs are now treated as parameters like “pages_location”. 


In Universal Analytics, almost everyone experiences sampling. Looking at your left-hand navigation, most of the standard reports are available unsampled. Sampling happens if you do certain actions, such as applying an advanced segment or a secondary dimension and your property exceeds 500,000 sessions between a particular date range. This will be indicated by a green shield icon and still is in GA4.

GA4 has both standard reports and Exploration. 

Standard reports in GA4 are always unsampled, even if you apply secondary dimensions, filters or comparisons. This provides more accurate reporting on unique users across platforms.

Exploration is an advanced tool that allows you to create custom reports, funnels and more. Analysis can have sampling. This mainly occurs if you didn’t replicate a pre-existing standard report and it exceeds 10 million events. There are sure to be more examples that pop up as more people start moving over.

Measurement protocol

Measurement Protocol is an API that allows developers to make HTTPS requests, sending data and events from a server to Google Analytics. For example, in the event of a sale, you can have the website’s payment platform’s server send a record of the transaction to GA. 

In Universal Analytics, people from outside of your organisation could use your GA ID and out that on their own server to send bots and spam data, such as random event values, directly to your Google properties. This is difficult to avoid. 

To tackle this, GA4 has introduced secrets

If you want to send data to your GA4 account, someone will need to create a secret. You can find Measurement Protocol API Secrets within Data Streams > [your stream name] > Additional Settings. 

This is great for when you just want to simply share your GA’s secret with someone else. For more complicated libraries, you’ll find there are limitations. 

The Measurement Protocol allows any device that can make HTTP calls to interact with GA including Apple TVs, game consoles, point of service systems and even slot machines – there are so many opportunities. There are still limitations with user data, however, like how Apple TV doesn’t have a web session to use.

Historical data limit

With Universal GA, you could make it so your data would never expire. 

With GA4, you may notice that your data is set to expire after just two months. Thankfully this is just the default which you can configure to store the data for up to 14 months. If you forget to do this, you’ll find yourself unable to retrieve data beyond two months in your Explore (previously the Analysis Hub).

To adjust: go to Admin > Data Settings > Data Retention and change to 14 months.

Conversion migration tool

To migrate your existing Universal Analytics goals into GA4, Google has rolled out a conversion migration tool. 

To find this, head to your GA4 settings > Setup Assistant > Conversions. You’ll need to have an Editor role.

From here, you can quickly recreate goals (if eligible) from your Universal Analytics property as conversion events in GA4. The tool automatically creates a new “create eventrule and marks the created event as a conversion. You’re limited to creating 30 custom conversion events per GA4 property.

The eligible goals are destination goals (like confirmation pages) and event goals (like playing a video or clicking an ad). Duration goals, Pages/Screens per session goals and Smart goals are not eligible, nor are any that use regular expressions.

13 Benefits of GA4

No gaps in the data & a cookie-less future

Google announced it was phasing out third-party cookies back in February 2020, but it has since announced that it won’t be building “alternate identifiers to track individuals as they browse across the web, nor will we use them in our products”. With this lack of third-party cookies, Google anticipates that data sparsity will become normal. 

Instead, Google will rely on machine learning to fill in any gaps in data. This is designed to be future-proof in a cookie-less world. GA4 is different to Universal Analytics in that it operates across platforms, using event-based data as its measurement. The goal is to reduce GA4’s reliance on cookies to record events, using machine learning to step in when user consent isn’t given for tracking. This should prevent data gaps in the future.

Identity methods are rebuilt

In Universal Analytics, you could only track anonymous users or logged in users. These were tracked in their own report suites and views and weren’t easily connecting users across different browsers, devices and platforms. Every time a user used a different platform or device, they’d be reported as an entirely new user.

Now, GA4 has rebuilt identity methods, there are several changes when Google uses multiple IDs. One is the new bridge identity, the other is Google Signals. 

What are Google Signals? This is Google’s identity graph of those logged into a Google account. If you opt into Google Signals and your users opt in with Google, you’ll be able to use their identity graph across devices using a pseudo-Google ID, improving your understanding of who your users actually are. This powers the entire set of standard reports in GA4, whereas in Universal Analytics, this was only available in a small set of reports.

Essentially, Google Signals allows you to follow a single user journey across their devices and platforms. 

User IDs are a unique, non-personally identifiable (meaning you can’t actually find out who they are) ID string used to identify and track a user. If you create your own using Google Tag Manager, you can import this into GA4 to enhance your cross-device reporting capabilities.

Device IDs are based on the user’s browser cookies (websites) or app-instance IDs (apps). Device IDs are used when custom IDs and Google Signals are not available (in that order of preference).

Audience capabilities

GA4 is more flexible than ever before, building on its already rich segmentation and audience capabilities to deliver brand new features. 

One of these is time-based sequences and time-based audiences. Previously, Universal Analytics didn’t do much to measure time, but now with GA4, time is meaningful. As an example, you could now see the time between the first visit and transaction, or add to cart and transaction. 

The ability to exclude audiences is greatly improved. This includes a more robust way to temporary exclude and permanently exclude, ideal for remarketing. 

As an example scenario, if someone purchased from you, you’d probably stop showing them ads. But if they came back and looked at more products, you’d want to start showing them again. For this, you can build a suppression list. This will temporarily exclude them for either a certain period of time or until they come back to the website and perform an action. They are then included as a paid marketing audience again.

Previously, only Adobe users could build event scoped audiences, while Google only allowed for session scoped or users scoped. Now, thanks to GA4’s event-driven data model, event scoped is now an additional option.

A fuller customer journey

By integrating all devices and combining web and mobile data into a single analytics property, GA4 is more focused on giving marketers a complete understanding of the customer journey in its entirety. 

This measures the shopping journey from end to end with its event-driven data model rather than just reporting individual metrics when it comes to devices, pages and segments. 

Privacy features

GA4 no longer uses or stores IP addresses. This is because they can be misused as personally identifiable data and compromise privacy. 

Instead, GA4 puts a big emphasis on privacy with more features and options to manage your data, helping advertisers to comply with GDPR regulations. One of these features is IP anonymisation, which is enabled by default. You also have the ability to delete an individual user from Exploration in the user explorer tab. 

You’ll also find consent mode. Ordinarily on Universal Analytics, if someone doesn’t give consent to be tracked, Google will lose all visibility and ability to track the user as it depends on having a client ID or alternative user identifier. GA4 introduces substantial updates to deal with this.

Consent Mode is set to power GA4 and aims to restore aggregate data using modelling rather than user IDs. 

Other privacy features include:

  • NPAs (non-personalised ads) – you’ll be able to make an event an NPA, telling Google not to use it for their advertising products.
  • Regional data settings – in Advanced Settings, you can find regional control for ads. This is useful if you’re not supposed to be doing ads based on GA data in a particular country or region.
  • Data deletions requests – these have been greatly improved and far more targeted to be less destructive. To delete users directly from user explorer reports, head to Explorer > User Explorer > Find a User ID.
  • Server-side GTM – this allows you to prevent IP addresses or anonymous identification techniques and to fully control, modify and manipulate all of the data.


One of the biggest benefits to GA is that direct integration with BigQuery is now completely free for GA4 users – even those with free accounts. Previously, this powerful platform was only possible for premium Universal Analytics users.

BigQuery, if you haven’t used it before, is an external Google Cloud platform where you can export all your raw Google Analytics data. It’s a serverless data warehouse that stores your GA data and allows you to build visualisations and get streaming tables.

This will become both your own marketing data warehouse and CDP custom data platform, giving you more power and potential over your analytics than ever before. Using real-time streams, you can have CDP activities like subscribing certain audiences to a particular email list or giving unique offer codes. It also allows you to do predictive analytics and build models to calculate things like who is most likely to convert or predictive LTVs (customer lifetime value). 

Previously, only those with the enterprise version of GA could get a record of everything a user did. Otherwise, it was impossible to scale at high volumes as a lot of data gets sampled using the alternatives, Google Data Studio or Tableau and you’d be limited to how many rows or columns of data you were allowed to export.

Setting up and linking BigQuery and GA4 is easy. Here’s how:

  1. In BigQuery, create a new project.
  2. In GA4, go to Admin > Properties > BigQuery Linking
  3. Link to the BigQuery project you just created
  4. Pick what streams to export (you can choose all)
  5. Select your frequency as either Daily streams (free) and/or Streaming (paid*). 
  6. Go to Google Cloud Platform > APIs and Services > search for BigQuery API > Enable
  7. Now, make sure you’re in the project at the top, then click on Manage > Credentials > Create Credentials > Service Account 
  8. Enter “” into Service Account Name. Click Create and then Done.

*Note: the streaming frequency option continuously exports data within seconds of events happening. To get this option, you need to upgrade to a proper BigQuery project. BigQuery is free up to a storage limit. 

To learn more, you can check out GA4’s BigQuery demo.

Out-of-the-box event tracking 

In Universal Analytics, you could only track pageviews across your properties. While there were the capabilities to track some additional interactions, you’d need Google Tag Manager and an advanced knowledge of event tracking to make it possible. 

GA4 introduces Enhanced Measurement. This now incorporates the auto-tracking libraries you’d previously have had to manually set up in Google Tag Manager. With this, you can track much more than just pageviews, even without editing your website’s code. You can automatically track time-based actions like scrolling, outbound link clicks and interaction and engagement with videos, file downloads and much more. 

From there, you can much more easily customise your event data in line with your needs, like being able to temporarily or permanently exclude certain users who meet certain conditions or exhibit particular behaviours. You may still want to customise further in GTM, or even disable some tracking, but it’s much more automated in GA than before.

With Enhanced Measurement, you get much more meaningful answers to your questions, such as how long it takes your users to complete a survey, or how long they watch your embedded videos for.

Codeless event tracking

GA4 introduces the new functionality to create/modify events. This allows you to mark any events as a conversion. 

Previously with Universal Analytics, you could identify a conversion that was easily defined, like a thank you page. You also could only set 20 goals, without the ability to reuse them. 

GA4 lets you track certain events automatically, with no need to set up event tracking in Google Tag Manager. You’ll also be able to see if an event happens multiple times in a session as counts, rather than just recorded as one. 

You’ll also be able to create more complex conversions with the audience trigger feature. This will create and send an event when a user is added to your audience, which can then be used for conversions. 

Modify Events makes it much easier to fix simple mistakes like mistagged events. You could end up with different variations of what should be the same one like scroll_tracking, scroll tracking and scroll. With Universal Analytics, you couldn’t really fix it at its source, you’d have to use filters or update the tags.

User scoped dimensions

Custom dimensions in GA4 have gone through some changes. It has the options for both event-scoped and user-scoped, which are filled out by user properties. 

User properties are attributes you may want to attach to a particular user such as loyalty level, first joined date, number of purchases or lifetime value. This will carry forward and update over time. 

Event scoped custom dimensions are passed individually on each custom event. This is useful when you expect a user to complete multiple events in a single session.


Previously called Analysis, GA4’s Exploration feature brings in advanced tools and techniques that help you dive much deeper into your users’ behaviours than the standard reports do. These include some of GA4’s most powerful and meaningful features: ad-hoc segments, funnels and pathing, which used to be paid options. 

Exploration is the freeform way to do your analysis and reporting, letting you build customised tools as and when you need to. It’s super flexible. For example, you can see the start and endpoints of a user’s journey, working both forwards and backwards to understand how they converted (or didn’t).

Here’s a breakdown of some of Explorations best tools:

Funnels were exclusively a paid feature before, now it’s available to everyone. And you can even visualise these as trended funnels, which will show you on a line chart how it’s performed over time. 

User Explorer acts similar to a session replay. You can see the client ids of all users with a particular behaviour, e.g: anyone who spent over a set amount. From there, you can click an individual user and see all their exact behaviour. 

Segment Overlap lets you find audience overlaps and mutually exclusive audiences. This is particularly useful for remarketing. Then you can start to create your own segments or review individual audiences based on this. 

User Lifetime is a brand new report that shows how users behave in their lifetime as a customer of your site. With this, you can see what source or campaign earned you the users with the highest lifetime value, see when your active users last purchased anything, and much more. 

The Cohort Report is similar to its original version in Universal Analytics but has been built upon to be much more flexible. 

New funnel reports

With the power of GA4, everyone can now build meaningful funnels.

Funnels haven’t been an option for those using the free version of Google Analytics, except for ones that are incredibly limited or inflexible. GA4 gives access to the analysis module and explorations to everyone – and it’s a more improved version.

With Exploration, funnels are freeform and segmentable, providing more flexibility than ever. 

You can create two different types of funnels: open and closed. Users can enter open funnels at any step along the funnel, while closed funnels have to start on the same first step. 

Other features include:

  • You can change the funnel with one click to see data over time.
  • You can turn on an elapsed time button to calculate the time between each of your funnel’s individual steps. 
  • You can use meaningful padding including backwards padding which allows you to work backwards from an outcome to see what they did before.

Real-time reporting

Real-time reports have been majorly improved to include more data and dimensions. Now you can actually see events, audiences, some custom dimensions and other signals in real-time. 


Goals in Universal Analytics have always been very limited and rather inflexible. You can’t reuse them, they only count once per session, the data is permanent and you can’t set seasonal goals or goals for things that will change with time. 

Thankfully, conversion tracking has been rebuilt for GA4 – you can simply toggle conversion on or off for different events in the events report. You can also easily create advanced conversions with the Create Events feature. This allows you to create events from other events and combine conditions, audience triggers and attributes, resulting in far more unique events than previously possible.

GA4 has also increased the goal limit from 20 to 30, but you can also now archive goals to free up space. 

How to get started

Implementation is all new and different

Moving to GA4 isn’t all that straightforward. 

When you log in for the very first time, everything will feel new and different to the analytics you’ve always used. 

For example:

  1. Setting up and deploying analytics and marketing tags isn’t the same as they are in Universal Analytics. 
  2. Conversions, audiences and events have to be rebuilt from scratch.
  3. Enabling enhanced measurement automatically measures events out of the box.

These are just a few reasons why complete migration to GA can be very time-consuming and difficult.

Universal Analytics is sunsetting on the 1st July 2023

While Google has given us 15 months until they sunset Universal, the earlier you collect data, the easier it’ll be to analyse later. Google has also said it will not port over historical data from existing GA accounts to GA4 since the platforms are too different and the data is stored in separate places. 

This means the longer you wait to set up your GA4, the less historical data you will have.

Google Tag Manager

The best practice for implementing GA4 is through Google Tag Manager. 

This allows the most amount of flexibility, letting you add changes and simply leverage everything you’re doing. If you currently use Google Tag Manager or the global site tag for Universal Analytics, there’s no tagging required for your website.

Things you should check: 

  • That Google Tag Manager is in the source code of your pages.
  • That you’ve published your GA4 tag in Google Tag Manager
  • That data is filtering in. You can do this by visiting the website in incognito mode and checking GA4 for real-time data.


One of your first steps, of course, is to create a new GA4 property. Thankfully, Google makes this easy with its GA4 Setup Assistant wizard which will take you through the process.

One important step to pay attention to is your time zone. This is important as Google needs to know when your day officially ends for daily reports. A day in GA4 ends at midnight, but that’s a different time for everyone. You should select the timezone of where your main headquarters are. 


Streams are not views. They’re really nothing alike. 

Streams are like streams of data. These stream data into a property, and then everything comes together in the user interface (UI). 

Where previously you had accounts, properties and views and would add your property ID to your website, with GA4 you would use a measurement ID attached to a stream. 

Here are things you can start doing:

  • To start creating filters, you go to the UI, not the individual view. 
  • You can set up cross-domain tracking in a single stream (for cross-domain attribution), or you can create multiple streams for domains that are completely separate. 
  • You can set up robust cross-device and cross-platform tracking. 
  • Explore the new tagging settings – there are plenty more.
  • Choose to exclude particular IPs and list unwanted referrals. 

Streams do result in some issues with data governance like permissions, lower case filters or the ability to delete query parameters, especially since filters are limited in GA4. 

Event tracking

Naturally, as an event-driven model, events are where you’ll find the most differences between GA4 and Universal Analytics. The good news is that events are far simpler and more intuitive. 

For one, GA4 lets you edit, correct and improve the way events are tracked without having to edit any onsite code. 

Understanding events

Since Universal Analytics uses a data model based on hits, you have to tag or define anything you want to track as an event. There was no option to combine pages and session-level metrics or to use conversion metrics alongside pages. Event tracking was simply far more limited in reporting and how much information you could collect.

With GA4’s event-based data model, everything is an event. 

There are four types: 

  • Automatically collected events
  • Enhanced measurement events
  • Recommended events
  • Custom events

You can set up automatically collected events and enhanced measurement events in GA4 without Google Tag Manager.

If you don’t want enhanced measurement enabled, you can go to Admin > Property > Data Streams > Web and then under enhanced measurement, you can toggle it on and off.

Understanding the new event schema

Events in Universal Analytics have always had a structure of category, action and label that is unique to GA.

For example:
Category: scroll tracking
Action: % of the page that was scrolled
Label: page name

With GA4, this has been modernised to just include an event name and event parameters. With each event, you can track up to 25 parameters.

Registering parameters

Parameters provide you with context about each event, such as where, how and why the event was logged. Parameters can include anything from page titles to article IDs and are comparable to Universal’s dimensions. 

You need to register your parameters in Google Analytics so you can see the values of the parameters that you’ve sent with your events. This is pretty important. 

To do this, go to Custom Definitions and then choose either Custom Dimensions or Custom Metrics and select Create.

Once you have a registered parameter, you can now modify events. This is a new feature that allows you to fix tagging issues by renaming or deleting parameters within GA4. 

Custom dimensions

You can use custom dimensions to track your own custom data in addition to what Google already tracks (including gender, age, region, source/medium, product, and goals). This could be to track what content a particular user is viewing, or whether or not users are logged in. 

Useful examples of potential custom dimensions include:

  • language;
  • page_location;
  • page_referrer;
  • page_title;
  • screen_resolution

You have a limit of  50 event-scoped custom dimensions and 25 user-scoped custom dimensions per property.

To set up custom dimensions, go to Configure (in the left nav), Custom definitions and Create custom dimensions. You can then choose your dimension name, description and either an event parameter (event scope) or user property (user scope), depending on which one you choose.

Automatically collected events

GA4 automatically tracks certain events, which you can find here. This includes both web and app events, as well as their parameters. 

A few worth mentioning are:

  • scroll: only when a 90% vertical depth becomes visible. For other variants of depth, you need to set up an event in GTM.
  • view_search_results: by the presence of a URL query parameter. If your website uses other query parameters or doesn’t use them you’ll need to set up a search event. 
  • video_start: for YouTube tracking, you need to enable the JS API support.
Custom & recommended events

GA4 has the functionality for you to create your own events to track. 

The best place to start is with Google’s premade list of recommended events. Here are a few key events:

  • select_content – to track actions within a page
  • select_promotion – to track the number of times a special offer was clicked
  • view_promotion – to understand the number of impressions of a special offer
  • generate_lead – to track the number of leads you’ve captured
  • view_item – to understand when people view particular products
  • add_to_cart – to track people adding items to their shopping cart
  • purchase – to track successful e-commerce transactions

You can also create your own completely custom events the same way, except you’ll need to create your own event name. 

You have a lot of flexibility in naming events, but it’s worth sticking to a consistent format. In terms of limits, you have a maximum of how long your event name can be, and you’re limited to 500 unique event names per client ID.

How to create a custom event

Set up GA4 tag

You’ll need to set up your GA4 tag in Google Tag Manager for this. 

To do this, you’ll need to find your Measurement ID. Go to your GA4 property > Admin > Data Streams and copy the Measurement ID (you’ll need this). 

Next, go to GTM, click New Tag and label your new GA4 Configuration Tag. You’ll then need to choose Google Analytics: GA4 Configuration and enter your Measurement ID. Select the box “Send a page view event when this configuration loads” and save.

Set up variables

GTM containers have two types of variables: built-in, which is available for commonly used tag and trigger configurations, and user-defined which is custom.

You’ll find plenty of built-in variables including pages, clicks, scrolling etc. Enable the ones that you need for your event.

Set up triggers

Custom event triggers track the interactions on websites and apps in GTM. 

To create a new one, on the left menu, click Triggers > New > Trigger Configuration and choose your trigger type. You’ll then need to configure the conditions that must be true to trigger your event. You can add or remove trigger conditions using the + and – symbols. Save.

Configure the tag

You now just need to actually create the event tag in GTM. 

To do this, under Tag Type, select Google Analytics GA4 Event and GA4 Tag under Configuration Tag. Name your custom event and connect it to your previously created trigger. Save.

Test your tag

It’s important to test your tags to make sure they work before you publish them. You can do this by clicking Preview (top right) on GTM. Enter the domain of where you’re testing the tags with Google Tag Assistant and connect. 

You’ll then be on your website. Complete all the steps necessary to trigger your event and head back to Tag Assistant. You should see your custom event under Tags Fired. 

If not, you’ll need to figure out why your trigger either didn’t work or why the tag didn’t fire, make the changes and test again until it does fire.

Publish the tag

Publishing your tag makes them live and ready to track. When you’ve successfully tested, it’s time to click Submit and enter the Version Name and Description. Simple as that. 

How to find custom events in GA4 Reports

After 24 hours, event data should start populating GA4 (if the event has been triggered, either organically or by you). 

To find the data, head to the Reports tab > Engagement > Events.


You should create and build your GA4 audiences in Explore – not the Audience tab. If you build your audience here, it’ll take that audience and publish it in the Audience tab. It’s then usable across your standard reports.

In Explore, tracking applies retroactively, but if you use the Audiences tab, it will only collect data from the moment you create the audience onwards.

Audience Triggers

Audience Triggers is a new GA4 feature that allows you to create all sorts of complex conversions. An audience trigger creates and sends events when users are added to your audience. 

Within the Audiences report, you can create your audience conditions (or use a template), with tons of powerful options available to do things like add sequences for order, add and exclude and modify the scopes.  

You’ll need to specify what event you want to fire each time a user enters your audience. (Tip: prefix them with something like audience_, so they’re easy to find and work with in the future.) You can then decide if you want the event to fire every time the user matches your conditions or not. 

When creating your trigger, you’ll be asked to choose membership duration. This is 30 days by default, but it’s worth adjusting this based on your sales cycle. If a user reenters your audience within that duration, it’s reset or extended. You have the option to track how many times a user has entered your audience.

Creating segments

The kind of Audiences you’re used to in Universal Analytics only exists in Explore, but you can find GA4’s version on audiences in your standard reports. 

Standard reports allow you to Add Comparison, adding up to four segments. This only allows basic segmentation and it’s worth noting that this isn’t the same as advanced segments. You cannot use metrics, regex, different match types or advance conditions.

To create a custom segment in GA4, you’ll need to choose free form in Explore. Here you can start building segments based on users, sessions and things like first-time events. From here you can scope the data. 

There are options for user scoped, session-scoped and event scoped segments. 

You can also temporarily or permanently exclude users that match particular settings. This can be used to suppress things like ads for them for a specified period of time.

Attaching sequences

Sequences are useful when the order of a user’s events matter. In GA4, you can only attach sequences to user segments. You add sequences in the condition group, delete the initial condition group and start creating the steps of your sequence.

You can now add time constraints to your sequences, e.g. show anybody on a desktop that visited the about page and visited the blog within 5 minutes/seconds/days (whatever you like). 

Integrating Google Ads

All Audiences are available in Google Ads unless you mark it as an NPA (Non-personalised ad). It’s better to use GA4’s audiences in Google Ads as they are typically more powerful, customisable and scalable than the ones built with Google Ad tags.

You can also use your user data from GA4  to create audience lists linked to Google Ads or even Search 360 for the purpose of ad personalisation.

Key dates

  • GA4 officially launched in October 2020
  • If you want some year-on-year data once the switch has happened, you really need to get GA4 set up before July 2022
  • Until 1st July 2023, Google Universal will continue to collect new data in your Universal Analytics properties
  • After 1st July 2023, Google will stop processing data and you’ll only be able to access historical data. Previously processed data in Universal Analytics will be kept for at least six months.
  • Universal Analytics 360 customers (enterprise version of GA) have until 1st October 2023

GA4 is a completely new version of analytics and doesn’t use any of the data that you’ve collected in the old Universal Analytics version. It requires new tags and will only collect data from the day you implement these tags and connect your data streams – it can’t collect data retroactively. 

That’s why it is important that you set up your GA4 property now and not wait until later. 

However, if you’re already using Firebase, historical data will be carried over. With this in mind, we recommend you may want to add the global tag in GA4 and begin collecting as much data as possible now. 


The exit metric is not currently available in standard reports. So instead, head to Explore and pick the Free Form report. In the variable column add either the dimensions Page Path and Screens or the Page Path + Query String. Then add the metrics Views and Exits.

In the tab settings column, remove the existing values and pull across the chosen page dimension into rows and the metrics into the values. Here you'll see pages visited and exits.


How to find Exit Rates in GA4

For better reporting, you can duplicate the entire tab and apply segments, like Device Type and/or Acquisition Channel.

Unfortunately, there isn’t a conversion rate metric in Google Analytics 4. You’ll need to use Google Data Studio to calculate the conversion rate for the actions you want to measure. See post:

There is a built-in video tracking feature in GA4, but it is quite limited. Here are the steps to track YouTube interactions on your website:

1. In GTM (Google Tag Manager), go to Triggers, select New and add the built-in YouTube video trigger. Name the trigger something like YouTube interactions. Along with the pre-selected Start and Complete, you can also enable the Progress checkbox (add the thresholds that you’d like to track when a visitor is watching, e.g. 10,25,50,75,90). Also, enable the Add JavaScript API Support To All YouTube Videos checkbox.

2. Go to Variables, click Configure and enable all the Built-in Video variable checkboxes.

3. In GTM’s preview mode, navigate to a page with a YouTube video and click play. Despite only clicking once, you'll notice that two events appear after you've started a YouTube video. This is happening if you still have enabled the Built-in Video tracking feature in GA4 as well. (To disable this, go to the Admin of your GA4 Property. Click Data Streams, select your data stream, click the Settings (gear icon), disable Video Engagement, and click Save. Once you refresh, you'll only see one event when you click start, and then another once the video is complete.)

4. Still in GTM, head to Tags and create a New Tag. Use the recommended event names from the video engagement section of this post on [GA4] Enhanced Measurement Events, such as video_start, video_progress and video_complete. Using the built-in video_status tag for the event name means that when the tag is fired, it will be replaced by the correct status (Start, Progress or Complete). Copy and paste additional event parameters from the post to your set-up, such as video name and length.

GTM YouTube video interactions tag

5. You can test whether this is working properly in the GTM Preview Mode and also the GA4 Debugger view.

6. To see these parameters in your GA4 standard reports, you’ll need to register them as Custom Dimensions. In the next 24 hours, you’ll start seeing video events in the Events tab and will also be able to start using them in reports.

Tracking Vimeo video interactions are slightly more complicated than YouTube. Carefully follow the steps below:

1. Loading the Vimeo tracking code on every page is a waste of resources. Instead, we add a variable that should activate that code only when the Vimeo player is embedded in the page.

In GTM, go to Variables, scroll down and click New. Add Custom Javascript variable. Copy and paste the following code:

function () {

for (var e = document.getElementsByTagName("iframe"), x=0; x < e.length; x++) {

if (/^https?:\/\/[x].src)) {

return true;



return false;


Name it ‘CJS – is Vimeo player on a page’ and click Save. If the Vimeo player is embedded in the page, this variable will return True.

2. Go to Triggers, and click New. Click Page View - Window Loaded. Add the variable you’ve just created.

Vimeo tracking GA4

Click Save.

3. To make the Vimeo interactions data available in debugger and preview mode, create a Custom HTML Tag. Copy and paste the following code (hat tip to Cardinal Path and Analytics Mania) and assign the Window Loaded - Vimeo Player is on page Trigger.


Google Analytics Tag Manager (V2) custom HTML tag for Vimeo video tracking

Copyright 2016, Cardinal Path, Inc.

Original author: Bill Tripple <>

Revised by: Bogdan Bistriceanu <>

Updated by: Julius Fedorovicius <> and Richard Outram <>

Version 2.1



var dataLayer = (typeof(dataLayer) !== "undefined" && dataLayer instanceof Array) ? dataLayer : [];

var videoLabels=[];

var lastP=[];

//we declare variables that will hold information about the video being played

var _playerTitle = {}, _playerAuthor = {}, _playerAuthorURL = {}, _playerUploadDate = {};






'event': 'gtm.error',

'errorMessage': e.message,

'tag': 'Vimeo Video Listener'



function init(){


var player=document.getElementsByTagName("iframe");

for (i = 0; i < player.length; ++i) {

var url=player[i].getAttribute("src");

if(/player\.vimeo\.com\/video/.test(url)){ // vimeo iframe found

if(!player[i].hasAttribute("id")){ // id attribute missing

player[i].setAttribute("id","vimeo_id_"+i); // add id attribute


var urlUpdated=false;

if(!/api=/.test(url)){ // check to see if api parameter is in src attribute




if(!/player_id=/.test(url)){ // check if player_id is in src attribute




if(urlUpdated){ // repopulate src attribute with added parameters



videoLabels[player[i].getAttribute("id")]=player[i].getAttribute("src"); // id to label dictionary



// Listen for messages from the player

if (window.addEventListener){

window.addEventListener('message', onMessageReceived, false);


else {

window.attachEvent('onmessage', onMessageReceived, false);






function updateUrl(url,param,value){


return url+((/\?/.test(url)) ? "&" : "?")+param+"="+value;





// Handle messages received from the player

function onMessageReceived(e) {


var data =;

if(typeof data === "string"){

data = JSON.parse(data);


switch (data.event) {

case 'ready':



case 'play':



case 'pause':



case 'timeupdate':








// Helper function for sending a message to the player

function post(action, value) {


var data = {

method: action


if (value) {

data.value = value;


var message = JSON.stringify(data);

var player = document.getElementsByTagName("iframe");

var url;

var prot;

for (i = 0; i < player.length; ++i) {



// Check if protocol exists

prot = player[i].getAttribute('src').split('?')[0].split('//')[0];

// If protocol doesn't exist, then need to append to "url"

if (!prot){

url="https:" + player[i].getAttribute("src").split('?')[0];


player[i].contentWindow.postMessage(data, url);







function getLabel(id){


return videoLabels[id].split('?')[0].split('/').pop();





//our function that will use the Vimeo oEmbed API to retrieve additional information about the video

function getVimeoInfo(url, callback) {

var script = document.createElement('script');

script.type = 'text/javascript';

script.src = url;



//the callback function which takes the data received from the Vimeo oEmbed API and places it into the corresponding objectes

function vimeoCallback(e){


_playerTitle[e['video_id']] = e['title'];

_playerAuthor[e['video_id']] = e['author_name']

_playerAuthorURL[e['video_id']] = e['author_url']

_playerUploadDate[e['video_id']] = e['upload_date']


function onReady(data) {


//execute our function which queries the Vimeo oEmbed API once the embedded videos are "ready"

getVimeoInfo(""+getLabel(data.player_id)+"&callback=vimeoCallback", vimeoCallback);

post('addEventListener', 'play');

post('addEventListener', 'pause');

post('addEventListener', 'finish');

post('addEventListener', 'playProgress');





function onPlay(data){


var t = - <= 1.5 ? 1 : (Math.floor( / * 4) / 4).toFixed(2);


event: "video",

video_action: "play",

video_url: '' + getLabel(data.player_id),

video_percent: * 100,

video_title: _playerTitle[getLabel(data.player_id)].toLowerCase()






function onPause(data){


var t = - <= 1.5 ? 1 : (Math.floor( / * 4) / 4).toFixed(2);


event: "video",

video_action: "pause",

video_url: '' + getLabel(data.player_id),

video_percent: * 100,

video_title: _playerTitle[getLabel(data.player_id)].toLowerCase()






// Track progress: 25%, 50%, 75%, 100%

function onPlayProgress(data) {


var t = - <= 1.5 ? 1 : (Math.floor( / * 4) / 4).toFixed(2); if (!lastP[data.player_id] || t > lastP[data.player_id]) {


if (parseFloat(t) != 0){


event: "video",

video_action: "progress",

video_url: '' + getLabel(data.player_id),

video_percent: t * 100,

video_title: _playerTitle[getLabel(data.player_id)].toLowerCase()










Vimeo video interactions tracking GA4

4. Check Preview and the Debugger in GA4 to see video events when you interact when Vimeo videos. Vimeo listener tracks the following video thresholds: 25%, 50%, 75%, 100% and there is no “complete” event.

5. To push the data from GTM to GA4, you’ll need to create the following Data Layer Variables:

Vimeo video interactions GA4

Do the same with video_url, video_title and video_percent.6. Create Custom Event Triggers that listen to all video events.

Go to Triggers, click New, and select Custom Event. Copy and save the following settings:

Vimeo tracking GA4

7. Still in GTM, head to Tags and create a New Tag. Copy the following configuration, including the additional event parameters, such as Video Title, Video Percent and Video URL.

Vimeo interactions GA4

8. You can test whether this is working properly in the GTM Preview Mode and also the GA4 Debugger view.

9. Don’t forget to register parameters as video_percent or video_title as custom dimensions (if you want to use them in your GA4 reports).


In your GA4 Property, go to Admin, and click Search Console Links under the heading Product Links. Click Link, and select your Google Search Console property that you would like to connect with your GA4 property. To do this, you need to be an editor of the GA4 property and a verified owner of the Search Console property. Then select the correct Web Stream. Click Submit. If successful, you’ll see a Link Created badge appear. In 24 hours, you’ll start seeing Search Console data in your standard reports.