On a quote page, the problem usually isn’t missing data but wrong data. A user who refreshes the form counts as two conversions, a submission that got a validation error shows up as successful, and the ad platform and GA4 show different numbers. Then budget decisions are made based on these numbers. This guide explains the implementation steps for marketing and web teams to set up landing page conversion tracking reliably with GA4 events, name campaign data consistently and verify the result. We assume that consent-based tag loading has already been solved.
Separating conversions from micro-conversions
Before touching a tag, write down what the word “conversion” means for this page. On a B2B quote page, the real conversion is a valid request that reaches the sales team. The intermediate steps along the way are micro-conversions: starting the form, downloading a brochure, clicking the phone number, scrolling to the pricing section.
The practical consequence is this: in GA4, only the real conversion is marked as a “key event”, and only that goes to the ad platform as the optimization goal. Micro-conversions are collected as events and used in reports, but aren’t given to the bidding algorithm as a goal. If you send phone clicks to the ad system with the same weight as the main goal, the system starts chasing easy but worthless interactions. The algorithm optimizes for whatever you give it.
Measurement plan table
The measurement plan is the document written before the tag setup that fixes each event’s name, trigger condition and parameters. The Google Tag Manager container is the implementation of this document, not the other way round. A container without a plan fills up within a few months with tags nobody can explain. An example plan for a typical quote page:
| Event name | Trigger condition | Parameters | Role |
|---|---|---|---|
generate_lead |
The server saved the form successfully | form_id, lead_type, value, currency | Key event |
form_start |
First input in the first field | form_id | Micro |
file_download |
Brochure PDF click | file_name | Micro |
phone_click |
Click on a tel: link |
link_location | Micro |
form_error |
The server returned a validation error | form_id, error_field | Diagnostics |
generate_lead is one of GA4’s recommended events; using the recommended names reduces the need for extra mapping in reports and ad integrations. Use lowercase and underscores in event and parameter names. Don’t change a name once it’s set; a name change in GA4 breaks continuity with historical data. Also write into the plan that custom parameters must be defined as custom dimensions in the GA4 admin panel to appear in reports; it’s one of the steps most often forgotten in the field. The primary source for the event schema and recommended events is the Google Analytics developer documentation.
Capturing form submissions reliably
There are three common ways to capture a form conversion, and their reliability isn’t the same:
| Method | Advantage | Limitation |
|---|---|---|
| Thank-you page view | Easy to set up | Refreshes and direct visits produce duplicate counts |
GTM form submission trigger or GA4 form_submit |
Requires no code | May not fire on AJAX forms, and can count failed submissions |
| dataLayer event tied to a successful response | Counts only saved requests | Requires the form plugin’s event or a small code snippet |
The third is the one to prefer. In WordPress, Contact Form 7 dispatches the wpcf7mailsent event on the DOM when a message is sent successfully; this event doesn’t fire on a validation error or a spam rejection. Code that passes the event to the dataLayer can look like this:
<script>
document.addEventListener('wpcf7mailsent', function (e) {
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({
event: 'generate_lead',
form_id: String(e.detail.contactFormId),
lead_type: 'quote'
});
}, false);
</script>
In GTM, a custom event trigger named generate_lead is created; the GA4 event tag and the ad platform’s conversion tag are attached to this trigger. If you use another form plugin, verify the success event in the plugin’s documentation; tools such as Elementor Pro forms have their own success events too. In forms you write yourself, send the event on the line where the successful response comes back from the server. Not on the button click.
To prevent duplicate counts, give each successful submission a unique request ID generated on the server side and carry it as an event parameter. In a Google Ads conversion action, when the “Count” setting is set to “One”, multiple requests from the same click count as a single conversion; in a lead generation scenario this is often the right choice.
UTM standard and campaign naming
GA4 reads campaign traffic from the utm_source, utm_medium, utm_campaign, utm_term, utm_content and utm_id parameters. Values are case-sensitive, and the default channel grouping relies largely on the utm_medium value. “E-mail”, “email” and “eposta” split the same channel into three separate rows and throw some of it under “Unassigned”. Whoever opens the report takes this for channel performance.
A written UTM standard should include at least the following:
- All values lowercase, hyphens instead of spaces; no Turkish characters.
- A fixed vocabulary for
utm_medium:cpc,paid-social,email,referral,display. Choose values compatible with GA4’s channel definitions. utm_campaignformat:yyyy-mm_product-or-service_goal; for example2026-11_server-maintenance_quote.utm_contentonly for the ad variant or link position.- When auto-tagging (gclid) is on in Google Ads, don’t add UTMs manually to Ads links; rely on auto-tagging. Never use UTMs on internal links; they change the session’s source.
Don’t write links by hand; generate them from a shared spreadsheet template. Before the campaign goes live, open the final URL in the browser and check in the GA4 real-time report that the source appears correctly.
When server-side tagging is needed
In server-side tagging, the browser sends events not directly to Google or the ad platforms but to a GTM server container running on your own subdomain; the container filters the data and forwards it to the target platforms. Setup and technical details are in the Google Tag Platform documentation.
This setup isn’t needed for every corporate website and landing page. A simple framework for the decision:
- May be necessary: If conversions are sent to multiple ad platforms, if you want to filter the data going to the platforms (IP, user agent, URL parameters) centrally, or if you want to reduce the third-party script load on the page.
- May be unnecessary: If there’s a single GA4 property and a single ad account, the monthly lead volume is low and there’s no team to take on hosting, monitoring and maintaining the server container. An unmaintained container is also a point of failure.
Server-side tagging doesn’t remove the consent requirement, and it doesn’t fix measurement errors either. A wrongly defined conversion goes out wrong from the server too. The client-side measurement plan must work correctly first. If the B2B sales cycle is long, the more valuable step is to feed requests marked “qualified” or “won” in the CRM back to the ad platform as offline conversions; this requires carrying the gclid value into the CRM together with the form entry. Since this value is linked to personal data, it should be added to the hidden field inventory in the KVKK-compliant contact form article.
Verification sequence and common mistakes
When setup is complete, run the tests in this order:
- Open the page in GTM preview mode (Tag Assistant), give consent and submit the form empty to get an error:
generate_leadshould not fire, andform_errorshould fire if it exists. - Submit the form with valid data:
generate_leadshould fire once, with the parameters filled in. - Verify in GA4 DebugView that the event and parameters arrive.
- Refresh the page and go back with the back button: no new conversion should be created.
- Arrive via a test link with UTMs; see in the real-time report that the session source is assigned correctly.
- After a week, compare the number of GA4 key events with the number of requests that reached the CRM. If the difference is larger than expected, look for the cause: consent rejection, ad blockers, duplicate counting or spam.
These are the mistakes we come across again and again in the field:
- The GA4 tag loads from both the theme and GTM; every event is counted twice.
- The thank-you page has been indexed and produces “conversions” from organic search.
- Cross-domain measurement hasn’t been set up for a redirect to a separate booking tool; the source gets lost as “referral”.
- Numbers are compared one to one without knowing that the ad platform’s conversion window and counting setting differ from GA4’s.
It’s normal for GA4 and ad platform numbers not to match exactly, because the attribution models are different. A difference is inevitable. What matters is that the difference stays stable and explainable; if it jumps within a week, something in the setup has broken.
Also monitor the impact of measurement scripts on page performance; the JavaScript budget and third-party scripts article is complementary in this respect. For the setup that loads tags after consent, see the cookie consent and tag management guide. For preparing the measurement plan and verifying the GTM setup, you can review our web analytics and conversion tracking service, and for the page itself our landing pages and lead generation pages service.
Frequently asked questions
Is the form_submit event in GA4’s enhanced measurement enough for conversions?
Often not. This event depends on the browser’s form submission behavior; it may never fire for forms submitted via AJAX, and it may fire for a submission that got a validation error. For conversions, use a custom event sent at the moment the server responds successfully.
Which is more reliable: a thank-you page or event-based tracking?
A thank-you page is easy to set up, but refreshing it, visiting it directly or having it indexed by a search engine produces duplicate or fake conversions. An event tied to a successful response is more reliable. If a thank-you page is used, at least give it noindex and check direct access with a unique ID.
Are UTM parameters case-sensitive?
Yes. GA4 reports “LinkedIn” and “linkedin” as separate sources. Set a standard that writes all UTM values in lowercase with hyphens, and generate links from a single template.
Does server-side tagging remove the need for cookie consent?
No. Server-side tagging changes the route the data takes, not the consent requirement. The consent state must also be passed to the server container; the data of visitors who haven’t consented must be handled under the same rules.