Google Analytics 4: how to set up a property and count leads

An online analytics course costs 25,000 ₸, and all the ads lead to a single page with a sign-up form (the numbers in this lesson are made up). Yesterday two people opened it: the first read the syllabus and closed the tab, the second submitted the form. In the report both of them produce the same page_view, and it tells you nothing about which one became a customer. To tell them apart, GA4 needs a lead event, and one you can trust.

Start with a measurement plan

GA4 records events: opened a page, scrolled, submitted a form. With each event you can send parameters that add detail. Before you configure anything, write down which business questions you want answered and which event answers each one. That table is your measurement plan. For a course page, four rows are enough:

Some events GA4 collects without any work on your side. page_view always arrives, and form_start and form_submit come from enhanced measurement, which Google recommends switching on when you create the stream (what it collects). But form_submit catches the click on submit, not the server's response: if the form returns an error, the event still arrives. And a form inside an embedded widget (an iframe) is invisible to GA4 on the page.

So a lead gets its own recommended event, generate_lead. In Google's list of recommended events it stands for submitting a form or a request for information. Next to it are qualify_lead for a lead someone has judged a good fit and purchase for a purchase. None of them is sent automatically; you set them up, for example through GTM. If no recommended event fits, you can create your own.

Event versus parameter

generate_lead answers "what happened", form_name answers "in which form". The site has two forms: course sign-up and a free consultation. One event, and the parameter tells you which form brought the lead.

The parameter reaches GA4 straight away, but it won't show up in reports until you register it as a custom dimension. Go to Admin → Data display → Custom definitions, open the Custom dimensions tab, click Create custom dimension, set the scope to Event and enter form_name in the Event parameter field. It appears in reports after 24-48 hours.

This is where it gets confusing: the Russian GA4 interface uses one word, "parameter", both for what you send with an event and for a report column (a dimension). And don't register values that are unique to every lead: the lead number, a client ID, the time of submission. Google warns that dimensions with a huge number of distinct values hurt reports and explorations. The lead number matters for the CRM link, and that link is built separately.

Create the property and connect it through GTM

The order for a test site or your first client:

1. In GA4 open Admin, click Create and choose Property. Enter a name, the currency (tenge) and a time zone that matches your ad accounts and CRM; otherwise daily numbers won't line up.
2. Click Add stream, choose Web and enter the site address. Turn on enhanced measurement; Google recommends it.
3. Copy the stream's Measurement ID; it starts with G-.
4. In GTM create a Google tag, paste that ID into it and attach it to the initialization trigger for all pages.
5. The lead needs a separate GA4 event tag in GTM named generate_lead with a form_name parameter. It fires on a dataLayer event the site sends once the server has accepted the form, not on a button click.
6. In Admin find Data retention and set it to 14 months, the maximum for a standard property. The setting affects explorations and funnels: with the short period, six months from now you won't be able to build a funnel for last quarter.
7. Publish the container once the lead shows up in DebugView (see below).

Mark the lead as a key event

A key event is the action the page exists for. For the course, that's generate_lead. GA4 marks purchase as a key event on its own.

• If generate_lead has already arrived, open Admin → Data display → Events, find it in the list and click the star.
• If it hasn't, click Create event on the same page, enter generate_lead and switch on Mark as key event. That way you can mark the event in advance, before the first lead comes in.

The mark applies from the moment you set it and doesn't recalculate past data (how to mark key events). The name has to match letter for letter: to GA4, generate_lead and Generate_Lead are different events (naming rules). A standard property can have up to 30 key events, but a star on every third event turns the report into noise.

Marking an event as key doesn't make it correct. If generate_lead fires on a button click rather than on an accepted lead, you are counting clicks under a nicer name. Google Ads doesn't learn anything from the mark either: for it to optimise towards leads, you create a conversion from the key event, which is a separate step (key events and conversions).

How to find the lead in DebugView

DebugView shows events from your own device almost immediately. It needs debug mode, and the easiest way to turn that on is GTM preview, which adds the debug parameter for you.

1. In GTM click Preview and open the site.
2. Submit a test lead.
3. In GA4 open Admin → Data display → DebugView. The stream should show page_view and generate_lead.
4. Click generate_lead and look at its parameters: form_name should be filled in.
5. Submit the form with an error, for example with an empty email field. This time generate_lead should not arrive.

If DebugView is empty, go through three points: did the Google tag fire on the page, does it carry your own G- ID, and did you decline analytics in the cookie banner yourself. When the site uses consent mode, events without analytics consent don't appear in DebugView.

Standard reports lag behind: GA4 needs a few hours to process data, sometimes up to two days (data freshness). You check DebugView today and the reports tomorrow. Leads by channel will be in the Traffic acquisition report: switch the table to Session source / medium and look at the Key events column. If you have only one key event, those are your leads by the UTM tags you put on your links.

What a lead is worth: why not value=1

generate_lead takes value and currency parameters, and if you send value, currency is required (event reference). It's tempting to set value=1 and currency=KZT on every lead just so the field isn't empty. That makes every lead worth one tenge. Reports pile up a total value that looks like money, and if you import that conversion into Google Ads and switch on a value-based strategy, the algorithm will believe each lead brings you one tenge.

There are two options. Don't send value at all and count leads as units. Or send an estimate: the course price times the share of leads that end up paying. With a 25,000 ₸ course and one lead in five paying, that's 5,000 ₸. Revisit the estimate once the CRM shows the real share.

If the course is bought online

When payment happens on the site, the purchase goes out as a purchase event. Here is what it looks like for the 25,000 ₸ course on a site where gtag.js sits directly in the page code:

Send it when the payment provider confirms the payment, not when the thank-you page opens. If GA4 is connected through GTM, as in this lesson, the same fields go through the dataLayer into a GA4 event tag for purchase, not into a second gtag call alongside it.

• value is the sum of price * quantity across all items, without shipping or tax: those go in their own parameters.
• currency is required whenever value is set; without it revenue is calculated inaccurately.
• transaction_id is the order number from your system. GA4 removes duplicate purchase events with the same number, but only in a web stream. Every order needs its own number: an empty string or one number for all orders will merge different purchases into one.
• A refund goes out as a refund event with the same transaction_id (ecommerce schema).

When you need the BigQuery export

When you need to join events to payments from the CRM, or calculate something missing from the reports, you connect the BigQuery export. It is available on free properties too, where the daily export is capped at a million events. BigQuery holds raw events without the processing GA4 applies to its reports, so the numbers may not match the interface. The export starts from the moment you connect it, and data arrives within a day.

You can look at the data in the free BigQuery sandbox, but tables there are deleted after 60 days. If the client plans to measure payback from actual payments, the project gets a billing account and the export is switched on from day one; otherwise the first months will be gone by the time you run the numbers. The join between events and payments is built on top of that export.

Task: your own GA4 and the 30-leads question

Make a test site with a form: a site builder or a single HTML page.

• Create a property and a web stream, and set data retention to 14 months.
• Connect the Google tag through GTM.
• Set up generate_lead with a form_name parameter that fires on an accepted lead.
• Mark generate_lead as a key event.
• Submit a test lead in preview mode and take a screenshot of generate_lead with its parameters in DebugView.
• Submit the form with an error and see that generate_lead does not arrive.

Now the question you'll be asked on your very first project. A month in, the client sends a GA4 screenshot showing 30 generate_lead events and writes in a report for their boss: "30 new customers". What do you tell them?

Thirty events means the tag fired thirty times. Among them can be the same form submitted twice, colleagues testing, and people who later didn't pick up the phone. With the "Once per event" counting method, which Google recommends, two submissions in one session give two key events (counting method). Only the CRM, where each lead has a payment status, will show customers. A better line for the report: "30 leads in GA4, of which so many paid according to the CRM". And for GA4 itself to see that difference, the CRM statuses are later sent back as qualify_lead and purchase events.

Video: a GA4 overview

The video is in English and works as a first tour of the interface.