---
title: "Track Form Submissions in WordPress (Server-Side Guide)"
description: "Why thank-you-page tracking misses leads, and how to fire lead events from Contact Form 7, WPForms, Gravity Forms and Fluent Forms server hooks."
canonical: https://traculo.com/track-form-submissions-wordpress-server-side/
updated: 2026-11-13
source: html
---

# Track Form Submissions in WordPress (Server-Side Guide)

> Why thank-you-page tracking misses leads, and how to fire lead events from Contact Form 7, WPForms, Gravity Forms and Fluent Forms server hooks.

[Home](https://traculo.com/)

[Blog](https://traculo.com/blog/)

Track form submissions in WordPress: Contact Form 7, WPForms and Gravity Forms

# Track form submissions in WordPress: Contact Form 7, WPForms and Gravity Forms

[Product Updates & Use Cases](https://traculo.com/category/product-updates-use-cases/)

Phillip Stemann

November 4, 2026

Last updated: November 13, 2026

![Title card reading Track form submissions in WordPress, from the server side, on a dark slate background with an orange glow](https://traculo.com/wp-content/uploads/2026/10/p14-featured.svg)

In this article

**Key takeaways**

- On a lead-gen site the form is the conversion, so a wrong form count means wrong ad optimisation. Thank-you-page and click-based tracking miss AJAX submits, break when redirects are blocked, and count spam and reloads.
- Each major form plugin exposes a server-side action that runs after the plugin has accepted the submission: `wpcf7_mail_sent` (Contact Form 7), `wpforms_process_complete` (WPForms), `gform_after_submission` (Gravity Forms) and `fluentform/submission_inserted` (Fluent Forms). Fire your lead event there.
- Gravity Forms is the odd one out: its hook [also runs for entries marked as spam](https://docs.gravityforms.com/gform_after_submission/), so you must check the entry status yourself.
- Capture UTMs, click IDs and the Meta browser cookies into hidden fields on landing, create one `event_id` per form view, and send that same ID from the browser and the server so Meta can deduplicate.
- Send hashed email and phone (SHA-256 after normalising), a value for lead scoring, and only what the visitor consented to. Then test with an invalid submit, a spam submit and a reload, not just the happy path.

A roofing company, a law firm and a B2B agency have the same problem. Nobody buys on the website. The form submission is the thing you optimise ads against, report to the client and argue about on Monday. If that one number is badly off in either direction, Smart Bidding and Meta’s delivery system learn from bad data, and so does your reporting.

Most WordPress form tracking is still built on two shaky ideas: “the visitor reached /thank-you/” and “the form’s submit button was clicked”. This post explains why both fail, and how to track leads from the server instead, using the hooks Contact Form 7, WPForms, Gravity Forms and Fluent Forms provide. Hook names and parameters come from each plugin’s developer documentation or source code, read in October 2026. The PHP samples are illustrative: they show the shape of the code, not a drop-in plugin.

## Why thank-you-page and DOM-event tracking fail

Look at what each approach actually observes. A thank-you page view tells you someone loaded a URL. A button click tells you someone clicked a button. Neither tells you the plugin accepted the submission.

![Two columns comparing thank-you page tracking, which depends on a redirect and page load, with server hook tracking, which fires once after validation and spam checks](https://traculo.com/track-form-submissions-wordpress-server-side/data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201200%20700'%3E%3C/svg%3E)

The browser path has four ways to be wrong. The server path has one gate: the plugin’s own acceptance of the submission.

### AJAX submits never load a new page

Many form plugins submit in the background and swap in a confirmation message. There is no page load, so a pixel attached to a thank-you URL never fires. Teams “fix” this by listening for a click on the submit button, which leads to the next problem.

### Clicks and validation errors

A click fires whether or not the email field was valid, the required box ticked or the captcha passed. On a form with five validation rules you will count every failed attempt as a lead. Contact Form 7 does emit a DOM event when mail has been sent (`wpcf7mailsent`, which the plugin’s front-end script dispatches when the server reports `mail_sent`, as seen in its [submit.js](https://github.com/rocklobster-in/contact-form-7/blob/trunk/includes/js/src/submit.js)), and that is better than a click. It still runs in the visitor’s browser, which brings the problems below.

### Redirects get blocked or broken

Plugins, themes, caching layers and consent tools can all interfere with a post-submit redirect. When the redirect fails, the lead is real, the thank-you page never loads, and the lead is missing from your reports. Our post on [why WordPress analytics data goes missing](https://traculo.com/wordpress-analytics-data-missing/) covers the wider pattern.

### Spam and reloads count as leads

If a bot posts directly to the thank-you URL, or a human reloads it, the pixel fires again. Add ad blockers and browsers restricting tags, and you get a number that is simultaneously too high (spam, reloads) and too low (blocked scripts, failed redirects). For the browser side of that story see [client-side vs server-side tracking in WordPress](https://traculo.com/client-side-vs-server-side-tracking-in-wordpress/).

## The server-side approach: fire after the plugin accepts

Every form plugin runs a pipeline on the server: parse the posted data, validate fields, run spam checks, save or email the submission, and show a confirmation. Each exposes an action at the end. Hooking in there means your lead event is tied to something the plugin itself decided was a real, valid submission.

![Reference table with the server-side hooks for Contact Form 7, WPForms, Gravity Forms and Fluent Forms: hook name, parameters and when each fires](https://traculo.com/track-form-submissions-wordpress-server-side/data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201200%20720'%3E%3C/svg%3E)

Hook reference. Gravity Forms is highlighted because its hook also fires for spam entries.

### Contact Form 7: wpcf7_mail_sent

This is based on the plugin source in its public repository ([submission.php](https://github.com/rocklobster-in/contact-form-7/blob/trunk/includes/submission.php)). In `WPCF7_Submission`, the `proceed()` method runs validation, the acceptance check, spam detection (the `wpcf7_spam` filter), file handling, the `wpcf7_before_send_mail` action, and then tries to send mail. If the mail goes out, the status becomes `mail_sent` and `do_action( 'wpcf7_mail_sent', $contact_form )` runs. Other outcomes include `validation_failed`, `spam`, `aborted` and `mail_failed`.

Two consequences. First, a validation failure or a spam verdict never reaches your hook, which is what you want. Second, your lead event is tied to *mail delivery*: if the server fails to send the notification email, the status is `mail_failed`, `wpcf7_mail_sent` does not run, and you lose the event for a real lead. Check that your mail setup is reliable before you build on this hook.

```
// Illustrative: Contact Form 7
add_action( 'wpcf7_mail_sent', function ( $contact_form ) {
    $submission = WPCF7_Submission::get_instance();
    if ( ! $submission ) {
        return;
    }
    $data = $submission->get_posted_data();
    my_send_lead_event( array(
        'form'     => $contact_form->title(),
        'email'    => $data['your-email'] ?? '',
        'event_id' => $data['event_id'] ?? '',   // hidden field
        'utm'      => array(
            'source'   => $data['utm_source'] ?? '',
            'campaign' => $data['utm_campaign'] ?? '',
        ),
        'gclid'    => $data['gclid'] ?? '',
    ) );
} );
```

`my_send_lead_event()` is a placeholder for whatever sends the event: your own code calling an API, or a function your tracking plugin provides. The posted-data array keys match your form tag names.

### WPForms: wpforms_process_complete

WPForms’ [`wpforms_process_complete`](https://wpforms.com/developers/wpforms_process_complete/) is an action that runs “at the very end of (successful) form entry processing”, after notifications and entry saving. It receives `$fields` (sanitised field values), `$entry` (the original `$_POST`), `$form_data` (form settings) and `$entry_id`. The entry ID is 0 if entry storage is disabled or you run the Lite version, so do not rely on it as your lead ID. A form-specific variant, `wpforms_process_complete_{$form_id}`, targets one form.

```
// Illustrative: WPForms
add_action( 'wpforms_process_complete', function ( $fields, $entry, $form_data, $entry_id ) {
    if ( absint( $form_data['id'] ) !== 5 ) {
        return; // only the "Request a quote" form
    }
    $email    = '';
    $event_id = '';
    foreach ( $fields as $field ) {
        if ( 'email' === $field['type'] ) {
            $email = $field['value'];
        }
        // Hidden field labelled "event_id" in the form builder.
        if ( 'hidden' === $field['type'] && 'event_id' === $field['name'] ) {
            $event_id = $field['value'];
        }
    }
    my_send_lead_event( array(
        'form'     => $form_data['settings']['form_title'],
        'email'    => $email,
        'event_id' => $event_id,
    ) );
}, 10, 4 );
```

WPForms’ [spam documentation](https://wpforms.com/docs/how-to-prevent-spam-in-wpforms/) lists an honeypot-based anti-spam layer on by default, Akismet, a minimum submission time, four captcha options and keyword and country filters. By default spam entries are stored so you can recover false positives. Their hook page says the action fires only after a successful submission, but we did not find a statement about entries that WPForms stores as spam. Test it with your own settings (see the QA section).

### Gravity Forms: gform_after_submission

[`gform_after_submission`](https://docs.gravityforms.com/gform_after_submission/) receives `$entry` and `$form` and runs at the end of the submission process, after validation, notifications and entry creation. The documentation is explicit about the catch: “This hook also runs for entries which are marked as spam.” Gravity Forms’ [`gform_entry_is_spam`](https://docs.gravityforms.com/gform_entry_is_spam/) filter flags an entry as spam and stops notifications and add-on feeds, but your own after-submission code still runs. A form-specific variant exists, `gform_after_submission_{FORM_ID}`.

```
// Illustrative: Gravity Forms
add_action( 'gform_after_submission', function ( $entry, $form ) {
    if ( 'spam' === rgar( $entry, 'status' ) ) {
        return; // never send spam as a lead
    }
    my_send_lead_event( array(
        'form'     => $form['title'],
        'email'    => rgar( $entry, '2' ),   // field ID 2 in this example
        'event_id' => rgar( $entry, '9' ),   // hidden field ID 9
    ) );
}, 10, 2 );
```

The docs say to check the entry status; the sample assumes the spam status value is `'spam'`, which the documentation reviewed here does not state, so confirm it by marking a test entry as spam and looking at what the hook receives.

### Fluent Forms: fluentform/submission_inserted

Fluent Forms’ [`fluentform/submission_inserted`](https://developers.fluentforms.com/hooks/actions/submission/) runs after the submission has been inserted in the database and passes `$submissionId`, `$formData` and `$form`. Their [submission lifecycle page](https://developers.fluentforms.com/submission-lifecycle/) shows validation first (including nonce, reCAPTCHA, hCaptcha and Turnstile checks), then data preparation, then insertion and the hook, then the confirmation response. It does not describe honeypot or Akismet handling in that sequence, so verify those on your own site. A legacy underscore name, `fluentform_submission_inserted`, appears in an older documentation URL, but the current developer docs use the slash form; use that on a current plugin version.

```
// Illustrative: Fluent Forms
add_action( 'fluentform/submission_inserted', function ( $submissionId, $formData, $form ) {
    my_send_lead_event( array(
        'form'     => $form->title,
        'email'    => $formData['email'] ?? '',
        'event_id' => $formData['event_id'] ?? '',
    ) );
}, 10, 3 );
```

### Keep the hook fast

These hooks run inside the visitor’s request. A synchronous call to an ad platform that takes two seconds is two seconds of spinner. Hand the event to a queue or a background job and return. If you use a plugin that forwards events from its own servers, that offloading is already done for you.

## What to send with a lead event

### One event ID, shared with the browser

Most lead sites keep the browser pixel as well as the server event, because the pixel carries cookies and ad-platform features that you do not want to lose. The danger is double counting. Meta’s [deduplication rules](https://developers.facebook.com/documentation/ads-commerce/conversions-api/deduplicate-pixel-and-server-events/) say the Pixel’s `eventID` must match the Conversions API `event_id`, the event names must match, and events are only deduplicated if they arrive within 48 hours of the first. When both arrive and are alike, Meta generally prefers the one received first and discards the later.

For forms: create a random ID when the form renders, store it in a hidden `event_id` field, fire `fbq('track', 'Lead', {}, {eventID: id})` from your form plugin’s success callback, and read the same value on the server hook. If the field is missing, the server should create its own ID rather than send none. The full story is in [Meta CAPI deduplication and event_id explained](https://traculo.com/meta-conversions-api-deduplication-event-id/).

### Hashed email and phone

Meta’s [customer information parameters](https://developers.facebook.com/documentation/ads-commerce/conversions-api/parameters/customer-information-parameters/) require email (`em`) and phone (`ph`) to be SHA-256 hashed after normalising: trim spaces, lowercase the email, and include the country code on phone numbers. IP address and user agent are sent unhashed. Google’s enhanced conversions for leads uses the same hashing idea with a few extra rules, such as dropping dots from Gmail usernames. We list them in the [Google Ads offline conversions guide](https://traculo.com/google-ads-offline-conversions-wordpress/). More hashed fields raise your Event Match Quality; [that post](https://traculo.com/event-match-quality-meta/) explains the score.

```
// Illustrative: normalise then hash
function my_hash( $value ) {
    return hash( 'sha256', strtolower( trim( $value ) ) );
}
$email_hash = my_hash( $email );
// Phone: strip spaces and symbols, add the country code first, then hash.
```

### A lead payload, annotated

```
{
  "event_name": "Lead",
  "event_time": 1792400000,
  "event_id": "lead_7f3a9c",             // same as the browser event
  "action_source": "website",
  "event_source_url": "https://example.com/request-a-quote/",
  "user_data": {
    "em": ["<sha256 of normalised email>"],
    "ph": ["<sha256 of normalised phone>"],
    "fbc": "fb.1.1792399000000.IwAR...",   // from the _fbc cookie or built from fbclid
    "fbp": "fb.1.1792300000000.1234567890", // from the _fbp cookie
    "client_ip_address": "203.0.113.7",     // not hashed
    "client_user_agent": "Mozilla/5.0 ..."  // not hashed
  },
  "custom_data": { "value": 150.00, "currency": "USD" }
}
```

This is an illustrative Meta Conversions API body with made-up values. The `fbc` and `fbp` formats come from Meta’s documentation (`fb.{subdomain index}.{creation time}.{fbclid}` and a random number for `fbp`). The required parameters are covered in the [Meta Conversions API guide](https://traculo.com/meta-conversions-api-for-wordpress/).

### A value for lead scoring

A lead has no price, but you can still give it a number. Use a fixed average (what a lead is worth at your close rate) or score from the form: a “budget over 10,000” answer is worth more than “just browsing”. Send it as `value` and `currency`, and it will also feed into Google Ads value-based bidding. Use a number, not text.

For Google Analytics 4, `generate_lead` is one of Google’s [recommended events](https://support.google.com/analytics/answer/9267735) for lead generation (“submits a form online or submits information offline”). The Measurement Protocol [requires a `client_id`](https://developers.google.com/analytics/devguides/collection/protocol/ga4/reference/events), so store the GA client ID in a hidden field too if you want server-sent leads to join the visitor’s browser session.

### Micro and macro conversions

Not every submission deserves the same weight. A newsletter signup or brochure download is a micro conversion; a quote request or booked call is a macro conversion. Give them different event names (and values), mark only the macro event as a conversion in ad platforms, and keep micro events for audiences and funnel analysis. You can then ask the more interesting question: which pages do visitors hit between the micro and the macro? See [goals, conversions and funnels](https://traculo.com/goals-conversions-funnels/).

## Capture campaign data into hidden fields

A server hook only sees what the form posted, plus request headers. It does not see the URL the visitor landed on three pages ago. That is why campaign data has to ride along inside the form.

![Flow from landing page URL parameters through first-party storage into hidden form fields and then to the server hook that sends the lead event](https://traculo.com/track-form-submissions-wordpress-server-side/data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201200%20640'%3E%3C/svg%3E)

Capture on landing, store, copy into hidden fields, read on the server.

1. **On every landing page**, a small script reads `utm_*`, `gclid`, `gbraid`, `wbraid` and `fbclid` from the URL and stores them in a first-party cookie or `sessionStorage`. Never overwrite a stored value with an empty one.
2. **When a form renders**, the script writes those values, the `_fbp` cookie and the GA client ID into hidden fields, plus a fresh `event_id`.
3. **On the server hook**, read those fields from the posted data.

Each plugin has a native way to fill fields. Gravity Forms lets any field, hidden included, be [populated dynamically](https://docs.gravityforms.com/allow-field-to-be-populated-dynamically/) from a query string parameter name (names are case-sensitive). WPForms has a `{query_var key="..."}` [smart tag](https://wpforms.com/docs/how-to-use-smart-tags-in-wpforms/). These read the *current* URL, so they work only on the landing page itself; once the visitor moves to a /contact/ page, you need the stored value from step 1 and JavaScript to inject it. Contact Form 7 has a `hidden` form tag (defined in the plugin’s hidden.php module), so check the exact syntax on your version.

The same setup serves Google Ads offline conversions: store the click ID with the lead, and send it back when the lead qualifies. [GCLID, GBRAID and WBRAID explained](https://traculo.com/gclid-gbraid-wbraid-explained/) shows what each ID means, and the same pattern applies to LinkedIn, covered in the [LinkedIn Conversions API guide](https://traculo.com/linkedin-conversions-api-wordpress/). If your hidden fields ride on a page cache, remember that cached HTML is the same for everyone, so fill the fields with JavaScript, not PHP.

## Consent and spam: two gates before you fire

### Consent

A form submission with a consent checkbox for contacting the visitor is not the same as consent to share data with ad platforms. Decide which signal you honour (for example, your consent banner’s marketing choice), store it in a hidden field at submit time, and have the server hook skip ad-platform sends when it is not granted. What the law requires is a question for your own advisor. For the mechanics see [Consent Mode v2 on WordPress](https://traculo.com/consent-mode-v2-wordpress/) and [does server-side tracking bypass consent?](https://traculo.com/does-server-side-tracking-bypass-consent/)

### Spam

The principle: spam checks must pass *before* your event fires. How that plays out differs per plugin, as the table above shows. Contact Form 7 evaluates spam before sending mail, so its hook is safe. Fluent Forms validates (including captchas) before insert. WPForms says its hook runs on successful processing, but check how stored spam entries behave. Gravity Forms fires the hook for spam, so you check the status. Use more than one layer (honeypot, captcha, time-to-submit), and treat a sudden jump in leads with no matching jump in sessions as a spam alarm. To reconcile platform counts afterwards, see [why ad platforms disagree with your orders](https://traculo.com/ad-platforms-report-more-conversions-than-woocommerce/).

## Test it: a QA checklist

![Checklist of ten checks for form tracking: valid submit, invalid submit, spam, reload, event ID match, hidden fields, hashing, consent, delivery and value](https://traculo.com/track-form-submissions-wordpress-server-side/data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201200%20700'%3E%3C/svg%3E)

Ten checks. The negative tests (invalid, spam, reload) catch most real-world errors.

- **Meta:** use the Test Events tool in Events Manager to see both the browser and server Lead event and whether they are deduplicated.
- **GA4:** use DebugView, and the Measurement Protocol validation server while developing, so malformed events show up as errors instead of silence.
- **Form plugins:** submit as a visitor in a private window with a test UTM and a made-up `?gclid=test123` on the URL, then read the entry (WPForms, Gravity Forms and Fluent Forms store entries; with CF7 you need an add-on that saves entries, or a log) to confirm the hidden fields arrived.
- **Negative tests:** an invalid email, a honeypot submit (fill the hidden trap field in dev tools), a failed captcha, and a page reload after success. None should send an event.
- **Duplicates:** submit twice quickly; you should see two leads with two event IDs, not two events with one.

## Where Traculo fits

Traculo’s WordPress plugin forwards events from its servers to GA4, Meta, Google Ads, LinkedIn, TikTok, Snapchat, Pinterest and Plausible, with a delivery log that shows each integration’s response per event. For a lead-gen site, that means the “send it to several platforms and keep a record” part can live outside your PHP. It also offers funnels with Pageview and Event steps, so a lead event can be the last step in a funnel such as landing page, pricing page, form.

Traculo’s plugin hooks the server-side submission events of a fixed list of form plugins: Elementor Pro Forms, Contact Form 7, Gravity Forms, WPForms, Kadence, Ninja Forms, Formidable, Fluent Forms, Forminator, MetForm, Jetpack Forms, Divi, WS Form, Everest Forms and Caldera, plus Bricks (with its Custom Action enabled) and Breakdance and Oxygen (once you add the Traculo Analytics action to the form). There is no generic fallback: a form plugin outside that list is not tracked automatically, only through a custom conversion built on a form or click selector. The form event carries the sanitized values that were submitted (payment and password-like fields are removed) and SHA-256 hashes of email, phone and name, so decide what you are comfortable passing on, and use the delivery log to verify with a test lead. Traculo does not replace a CRM, and it will not decide what a qualified lead is for you.

## Frequently asked questions

### Why not just track the thank-you page?

It breaks when the form submits with AJAX (no new page), when a redirect is blocked, and it counts reloads and direct visits. It also cannot tell a spam submission that reached the page from a real one. A server hook only fires after the plugin accepted the submission.

### Which hook should I use for Contact Form 7?

`wpcf7_mail_sent`, which the plugin source fires after validation, spam checks and a successful mail send. Note that a failed email means no hook call, so a lead can go unrecorded if your mail delivery is flaky.

### Does the Gravity Forms hook fire for spam?

Yes. Gravity Forms’ own documentation says `gform_after_submission` also runs for entries marked as spam, so check the entry status before sending an event.

### Do I still need the browser pixel?

Often yes, since the pixel sets cookies such as `_fbp` and contributes to matching. Keep both, share one event ID and the same event name, and Meta will deduplicate events that arrive within 48 hours.

### How do I get UTMs and click IDs into the server event?

Store them on landing, copy them into hidden form fields when the form renders, and read them from the posted data in the hook. The server cannot see earlier page URLs on its own.

## Related reading

- [WooCommerce server-side tracking: purchases, refunds, subscriptions](https://traculo.com/woocommerce-server-side-tracking/)
- [Elementor form tracking beyond GA4](https://traculo.com/elementor-form-tracking-meta-google-ads/)
- Client reporting for WordPress agencies
- [Meta Conversions API for WordPress: the complete guide](https://traculo.com/meta-conversions-api-for-wordpress/)
- [Google Ads offline conversions for WordPress leads](https://traculo.com/google-ads-offline-conversions-wordpress/)
- [GCLID, GBRAID and WBRAID explained](https://traculo.com/gclid-gbraid-wbraid-explained/)
- [LinkedIn Conversions API for WordPress](https://traculo.com/linkedin-conversions-api-wordpress/)
- [GA4 server-side tracking for WordPress](https://traculo.com/ga4-server-side-tracking-for-wordpress/)
- [Server-side tracking for WordPress: a beginner’s guide](https://traculo.com/server-side-tracking-for-wordpress/)

If you want lead events forwarded to several ad platforms with a delivery log you can check, see how Traculo handles [goals, conversions and funnels](https://traculo.com/goals-conversions-funnels/) and its [integrations](https://traculo.com/integrations/).

Share

[LinkedIn](https://www.linkedin.com/sharing/share-offsite/?url=https://traculo.com/track-form-submissions-wordpress-server-side/) [X](https://x.com/intent/tweet?url=https://traculo.com/track-form-submissions-wordpress-server-side/&text=Track%20form%20submissions%20in%20WordPress:%20Contact%20Form%207,%20WPForms%20and%20Gravity%20Forms) [Email](mailto:?subject=Track%20form%20submissions%20in%20WordPress:%20Contact%20Form%207,%20WPForms%20and%20Gravity%20Forms&body=https://traculo.com/track-form-submissions-wordpress-server-side/)

- [Contact Form 7](https://traculo.com/tag/contact-form-7/)
- [Fluent Forms](https://traculo.com/tag/fluent-forms/)
- [Forms](https://traculo.com/tag/forms/)
- [Gravity Forms](https://traculo.com/tag/gravity-forms/)
- [Lead generation](https://traculo.com/tag/lead-generation/)
- [server-side tracking](https://traculo.com/tag/server-side-tracking/)
- [WPForms](https://traculo.com/tag/wpforms/)

About the author

### Phillip Stemann

I've been working with marketing since the early 2010s. There has always been a problem with tracking, even before we were fully cookie-based. Now with server-side tracking, we have a more reliable way to measure what actually happens on your site.

[X](https://x.com/phillipstemann) [Facebook](https://www.facebook.com/pstemann) [LinkedIn](https://www.linkedin.com/in/phillip-stemann) [Instagram](https://www.instagram.com/pstemann) [YouTube](https://www.youtube.com/@PhillipStemann)

## Track what matters, without the guesswork

Traculo gives WordPress sites analytics, funnels and server-side event forwarding in one dashboard. Start on the free plan with 10,000 events a month.

[Try Traculo free](https://app.traculo.com/register)

## Related articles

[![Title card: Do you need a cookie banner for WordPress analytics?](https://traculo.com/wp-content/uploads/2026/10/p21-featured.svg)](https://traculo.com/cookie-banner-wordpress-analytics/)

[Privacy & Compliance](https://traculo.com/category/privacy-compliance/)

November 20, 2026

### [Do you need a cookie banner for WordPress analytics?](https://traculo.com/cookie-banner-wordpress-analytics/)

Whether WordPress analytics needs a cookie banner depends on what you store and your country's rules. CNIL, Denmark, Ireland, Germany compared.

[Read more](https://traculo.com/cookie-banner-wordpress-analytics/)

[![Title card: GDPR and WordPress analytics: the Danish picture](https://traculo.com/wp-content/uploads/2026/10/p20-featured.svg)](https://traculo.com/gdpr-wordpress-analytics-denmark/)

[Privacy & Compliance](https://traculo.com/category/privacy-compliance/)

November 18, 2026

### [GDPR and WordPress analytics: the Danish picture](https://traculo.com/gdpr-wordpress-analytics-denmark/)

What Datatilsynet, DIGST, the CNIL and the EU-US Data Privacy Framework say about WordPress analytics in Denmark, as of October 2026. Not legal advice.

[Read more](https://traculo.com/gdpr-wordpress-analytics-denmark/)

[![Title card: How much data do ad blockers cost a WordPress site?](https://traculo.com/wp-content/uploads/2026/10/p19-featured.svg)](https://traculo.com/ad-blockers-wordpress-analytics/)

[Privacy & Compliance](https://traculo.com/category/privacy-compliance/)

November 16, 2026

### [How much data do ad blockers cost a WordPress site?](https://traculo.com/ad-blockers-wordpress-analytics/)

What ad blockers actually block, what the public numbers show, and how to measure your own analytics loss on WordPress using logs, GA4 and Search Console.

[Read more](https://traculo.com/ad-blockers-wordpress-analytics/)

---
Source: https://traculo.com/track-form-submissions-wordpress-server-side/
