Purpose

This process explains how to track form conversions properly on websites that use Formidable Forms, Google Tag Manager, and GA4.

The goal is to track real form completions, not just button clicks.

A person can click “Submit” without actually submitting the form. They may miss a required field, fail validation, or get blocked by spam protection. That is why we only want to count the conversion after Formidable confirms the form was successfully submitted.

The standard is:

Track the successful form submission, not the submit button click.

The basic idea

The tracking setup works like this:

Formidable confirms the form submitted successfully
→ GTM notices that successful submission
→ GTM sends the right event to GA4
→ GA4 records it as a conversion/key event

This gives us cleaner reporting and makes before/after website performance easier to measure.

Step 1: List the forms on the site

What to do

Go to:

Formidable → Forms

Create a list of the forms that exist on the site.

Use this format:

Form ID	Form Key	Form Name	Purpose	Track?	Event Name	Conversion Type

Why this matters

Not every form should count as a conversion.

Some forms are important business leads. Others might be old campaign forms, test forms, internal forms, newsletter forms, or event registration forms. If we track everything the same way, the data becomes messy and less useful.

This step helps decide what each form actually means before setting up the tracking.

Step 2: Decide what type of conversion each form is

What to do

For each form, decide what kind of action it represents.

Use broad event names for GA4, then use a more specific conversion type to explain the form.

Form type	Event name	Conversion type
Contact / inquiry form	`generate_lead`	`contact_lead`
Quote / project request	`generate_lead`	`quote_request`
Landing page lead form	`generate_lead`	`landing_lead`
Free audit / consultation	`generate_lead`	`audit_request`
Newsletter signup	`newsletter_signup`	`newsletter_signup`
Gated resource / checklist	`resource_signup`	`resource_signup`
Event / webinar registration	`event_registration`	`event_registration`
Job / volunteer application	`application_submit`	`application_submit`
Internal / test form	Do not track	`internal_test`

Why this matters

GA4 should stay clean and easy to read.

Instead of creating a completely different event for every single form, we use broad event names like:

generate_lead
newsletter_signup
event_registration

Then we separate the details with parameters like:

form_key
form_name
conversion_type
form_location

This lets us answer both:

How many leads did we get?

and:

Which form created those leads?

Step 3: Turn on AJAX for tracked forms

What to do

For each form that should be tracked, go to:

Formidable → Forms → Edit Form → Settings → General

Turn on:

Submit this form with AJAX

Do not change the thank-you message or redirect unless needed.

Why this matters

AJAX lets Formidable submit the form without fully reloading the page. More importantly, it gives us a reliable “success” moment to track.

That means tracking happens after Formidable confirms the form worked, not when someone simply clicks the submit button.

Step 4: Add the Formidable success listener in GTM

What to do

In Google Tag Manager, create a new tag:

Tag type: Custom HTML
Tag name: HTML - Formidable success listener
Trigger: DOM Ready - All Pages

Add this script:

<script>
(function() {
  function pushFormSuccess(form, method) {
    window.dataLayer = window.dataLayer || [];

    var $ = window.jQuery;
    var formID = '';
    var formKey = '';

    if ($ && form) {
      formID = $(form).find('input[name="form_id"]').val() || '';
      formKey = $(form).find('input[name="form_key"]').val() || '';
    }

    window.dataLayer.push({
      event: 'form_submit_success',
      form_provider: 'formidable',
      form_id: formID,
      form_key: formKey,
      form_location: window.location.pathname,
      page_title: document.title,
      tracking_method: method
    });
  }

  function initFormidableTracking() {
    if (!window.jQuery) {
      return;
    }

    jQuery(document).on('frmFormComplete', function(event, form, response) {
      pushFormSuccess(form, 'formidable_ajax_success_message');
    });

    jQuery(document).on('frmBeforeFormRedirect', function(event, form, response) {
      pushFormSuccess(form, 'formidable_ajax_redirect');
    });
  }

  if (document.readyState === 'complete' || document.readyState === 'interactive') {
    initFormidableTracking();
  } else {
    document.addEventListener('DOMContentLoaded', initFormidableTracking);
  }
})();
</script>

Why this matters

This script listens for successful Formidable submissions and tells GTM when they happen.

The script is intentionally generic. It does not need to know every form name or form category. That way, we do not have to edit the code every time a new form is added.

Step 5: Create Data Layer Variables in GTM

What to do

In GTM, create these Data Layer Variables:

GTM variable name	Data Layer Variable Name
`DLV - form_provider`	`form_provider`
`DLV - form_id`	`form_id`
`DLV - form_key`	`form_key`
`DLV - form_location`	`form_location`
`DLV - tracking_method`	`tracking_method`

Why this matters

The listener sends form details into GTM. These variables let GTM read those details and pass them into GA4.

Without these variables, we might know that a form submitted, but not which form it was.

Step 6: Create Lookup Tables in GTM

What to do

Create lookup tables that classify forms based on their form_key.

Think of a lookup table like a simple matching list:

If the form key is "contact", call it generate_lead.
If the form key is "newsletter", call it newsletter_signup.

Lookup Table 1: GA4 Event Name

Create a variable:

Variable type: Lookup Table
Variable name: LUT - GA4 Event Name
Input variable: {{DLV - form_key}}

Example:

Input	Output
`contact`	`generate_lead`
`quote-request`	`generate_lead`
`newsletter`	`newsletter_signup`
`webinar-registration`	`event_registration`
`resource-download`	`resource_signup`

Default value:

generate_lead

Lookup Table 2: Conversion Type

Create a variable:

Variable type: Lookup Table
Variable name: LUT - Conversion Type
Input variable: {{DLV - form_key}}

Example:

Input	Output
`contact`	`contact_lead`
`quote-request`	`quote_request`
`newsletter`	`newsletter_signup`
`webinar-registration`	`event_registration`
`resource-download`	`resource_signup`

Default value:

form_submission

Optional Lookup Table 3: Form Name

Create a variable:

Variable type: Lookup Table
Variable name: LUT - Form Name
Input variable: {{DLV - form_key}}

Example:

Input	Output
`contact`	`Contact Form`
`quote-request`	`Quote Request Form`
`newsletter`	`Newsletter Signup`

Default value:

Formidable Form

Why this matters

This is what makes the setup easy to maintain.

When a new form is added, the script does not need to change. If the new form needs a specific label or event type, only the GTM lookup table needs to be updated.

Step 7: Create the Custom Event trigger

What to do

In GTM, create a trigger:

Trigger type: Custom Event
Trigger name: CE - form_submit_success
Event name: form_submit_success
Fires on: All Custom Events

Why this matters

This trigger tells GTM:

When a successful Formidable submission happens, fire the GA4 event tag.

Step 8: Create the GA4 Event tag

What to do

In GTM, create a GA4 Event tag:

Tag name: GA4 - Formidable Form Success
Event name: {{LUT - GA4 Event Name}}
Trigger: CE - form_submit_success

Add these event parameters:

Parameter name	Value
`form_provider`	`{{DLV - form_provider}}`
`form_id`	`{{DLV - form_id}}`
`form_key`	`{{DLV - form_key}}`
`form_name`	`{{LUT - Form Name}}`
`conversion_type`	`{{LUT - Conversion Type}}`
`form_location`	`{{DLV - form_location}}`
`tracking_method`	`{{DLV - tracking_method}}`

Why this matters

This is the part that sends the event into GA4.

The event name gives GA4 the main category, such as:

generate_lead
newsletter_signup
event_registration

The parameters give the extra details, such as which form it came from and where it was submitted.

Step 9: Test in GTM Preview

What to do

Open GTM Preview and test the form.

First, test a failed submission:

Leave required fields blank
Click submit
Confirm no form_submit_success event appears

Then test a successful submission:

Fill out the form properly
Submit the form
Confirm form_submit_success appears
Confirm GA4 - Formidable Form Success fires once
Confirm the form details are populated

Check for values like:

form_id
form_key
form_name
conversion_type
form_location
tracking_method
form_provider

Why this matters

The failed submission test is just as important as the successful one.

The whole point is to make sure failed attempts do not count as conversions.

Step 10: Confirm GA4 receives the event

What to do

Check GA4:

GA4 → Realtime
GA4 → Admin → Data display → DebugView

Look for the event, such as:

generate_lead
newsletter_signup
event_registration

Click into the event to check the extra form details.

If GTM says the event fired but GA4 shows nothing, check for:

Wrong Measurement ID
Consent blocking
Ad blockers
Content Security Policy blocking Analytics requests

Why this matters

A tag firing in GTM does not always mean GA4 received the data. Browser settings, consent tools, or security rules can block the request.

We only consider the setup complete once GA4 is actually receiving the event.

Step 11: Mark key events in GA4

What to do

In GA4, mark important events as key events.

Common examples:

generate_lead
newsletter_signup
event_registration
resource_signup
application_submit

Path:

GA4 → Admin → Data display → Events

Why this matters

Sending an event to GA4 records the action. Marking it as a key event tells GA4 that the action matters to the business.

Step 12: Create custom dimensions in GA4

What to do

Go to:

GA4 → Admin → Data display → Custom definitions

Create event-scoped custom dimensions for:

Dimension name	Event parameter
Form Provider	`form_provider`
Form ID	`form_id`
Form Key	`form_key`
Form Name	`form_name`
Conversion Type	`conversion_type`
Form Location	`form_location`
Tracking Method	`tracking_method`

Why this matters

GA4 can collect extra parameters without making them easy to use in reports. Custom dimensions make those details available in reporting and Explorations.

This lets us answer questions like:

Which forms are creating leads?
Which pages are generating submissions?
Which conversion types are performing best?

Step 13: Publish GTM

What to do

Only publish once these are confirmed:

Failed form submission does not fire
Successful form submission does fire
GA4 tag fires once
Form details are populated
GA4 receives the event

Suggested version name:

Add Formidable success-based form tracking

Suggested description:

Adds success-only Formidable form tracking through GTM and GA4. Events are triggered from confirmed Formidable submissions and include form ID, form key, form name, conversion type, form location, tracking method, and form provider.

Why this matters

Publishing bad tracking can damage reporting. Once this goes live, it becomes the source of truth for form conversions, so it needs to be tested first.

Ongoing process for new forms

When a new form is added:

Confirm AJAX is enabled
Decide if the form should count as a conversion
Update GTM lookup tables if it needs a specific event name or conversion type
Test failed and successful submissions
Publish GTM changes if needed

The listener script should not need to change.

Final standard

For Formidable form conversion tracking:

Track successful submissions, not button clicks.
Use one generic GTM listener.
Classify forms with GTM lookup tables.
Use broad GA4 event names.
Use parameters for the form details.
Test before publishing.
Confirm GA4 receives the event.

How Hub: Proper Form Conversion Tracking with Formidable, GTM, and GA4

Purpose

The basic idea

Step 1: List the forms on the site

What to do

Why this matters

Step 2: Decide what type of conversion each form is

What to do

Why this matters

Step 3: Turn on AJAX for tracked forms

What to do

Why this matters

Step 4: Add the Formidable success listener in GTM

What to do

Why this matters

Step 5: Create Data Layer Variables in GTM

What to do

Why this matters

Step 6: Create Lookup Tables in GTM

What to do

Lookup Table 1: GA4 Event Name

Lookup Table 2: Conversion Type

Optional Lookup Table 3: Form Name

Why this matters

Step 7: Create the Custom Event trigger

What to do

Why this matters

Step 8: Create the GA4 Event tag

What to do

Why this matters

Step 9: Test in GTM Preview

What to do

Why this matters

Step 10: Confirm GA4 receives the event

What to do

Why this matters

Step 11: Mark key events in GA4

What to do

Why this matters

Step 12: Create custom dimensions in GA4

What to do

Why this matters

Step 13: Publish GTM

What to do

Why this matters

Ongoing process for new forms

Final standard