---
title: "Elementor form tracking beyond GA4: Meta and Google Ads - Traculo"
description: "Elementor forms submit over AJAX. Learn the server-side hook, hidden fields, event_id sharing and consent steps to send leads to GA4, Meta and Google Ads."
canonical: https://traculo.com/elementor-form-tracking-meta-google-ads/
updated: 2026-11-13
source: html
---

# Elementor form tracking beyond GA4: Meta and Google Ads - Traculo

> Elementor forms submit over AJAX. Learn the server-side hook, hidden fields, event_id sharing and consent steps to send leads to GA4, Meta and Google Ads.

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

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

Elementor form tracking beyond GA4: Meta and Google Ads

# Elementor form tracking beyond GA4: Meta and Google Ads

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

Phillip Stemann

November 6, 2026

Last updated: November 13, 2026

![Title card reading Elementor form tracking beyond GA4: Meta and Google Ads on a dark slate background with an orange glow](https://traculo.com/wp-content/uploads/2026/10/p15-featured.svg)

In this article

**Key takeaways**

- MonsterInsights’ [Elementor forms guide](https://www.monsterinsights.com/how-to-track-elementor-forms-in-google-analytics/) is a good way to get form submissions into GA4 without Google Tag Manager. It does not cover Meta, Google Ads, server-side sending or popups, and that is the gap this post fills.
- Elementor Pro forms submit over AJAX, so the page often never reloads. A tag that waits for a thank-you page URL will miss every submission that uses the on-page success message.
- Elementor’s developer docs describe a server-side hook, `elementor_pro/forms/new_record`, that runs after the form actions. It gives you the full record, including hidden fields, in PHP. That is the right place to call GA4, Meta and Google Ads.
- Hidden fields carry the click ID, UTMs, an `event_id` and a consent flag from the landing page into the record. Without them the server hook has nothing to match on.
- Cached pages and popups are where this breaks. Test both, on a real cached URL, before you trust a single number.

Elementor Pro’s documented form actions do not include one that says “send this form to Meta and Google Ads”. It gives you a form, a list of actions, and a set of hooks. Everything else is wiring you add. The most common wiring is a GA4 event, and that part is well covered. The parts that decide whether your ad spend learns anything, a Lead event in Meta and an uploaded conversion in Google Ads, mostly are not.

This guide walks through how an Elementor form submit actually travels, where you can intercept it, and how to send one clean event to three platforms with a shared ID. Elementor facts come from Elementor’s own help and developer pages, fetched in October 2026. Code samples are illustrative: they follow the documented hooks, but you must adapt and test them on your own site.

## Where the MonsterInsights guide stops

The MonsterInsights article is the starting point many Elementor site owners find, so it is worth describing fairly. It says most tutorials walk you through setting up Google Tag Manager, and it offers an alternative: install the MonsterInsights plugin, connect it to Google Analytics, activate the Forms addon, and form submissions are tracked without a thank-you page or event setup. It describes a `generate_lead` event for submissions and lists Elementor among the supported form plugins. The addon needs a Pro license, per the guide.

For the stated goal, GA4 events with no tag manager, that is a reasonable route. What the guide does not cover, as of October 2026:

- Meta (Pixel or Conversions API) and Google Ads. It is a GA4 guide.
- Server-side sending of any kind.
- Popup forms.
- Capturing click IDs or UTMs into the form so a lead can be matched later.

None of that is a criticism. A GA4 key event tells you which pages produce leads. It does not tell Meta which ad produced one, and it does not tell Google Ads which click became a customer. Those need identifiers and platform APIs, which is the rest of this post.

## How an Elementor Pro form submits

The Elementor form widget submits with AJAX, so the visitor stays on the same page while the request runs in the background and a success or error message appears inline. Elementor’s help center lists what can happen next under **Actions After Submit**. The options documented there include [Collect Submissions, Email, Email 2, Redirect, Webhook](https://elementor.com/help/wp-json/wp/v2/posts/363), a set of marketing integrations (ActiveCampaign, ConvertKit, Discord, Drip, GetResponse, MailChimp, MailerLite, Slack, AWeber), and Popup. Collect Submissions sends the information to WP-Admin. Redirect “will take your users to a different page”, for example a thank-you page. Webhook hands the data to a third-party platform.

That matters for tracking because the common trigger, “the thank-you page loaded”, only exists if you chose Redirect. With the default inline message there is no new URL, no new pageview, and nothing for a URL-based trigger to see. Browser-side workarounds exist: a widely shared jQuery pattern listens for the `submit_success` event that Elementor emits in the browser and pushes a dataLayer event, as in this [Martech Zone example](https://martech.zone/how-to-track-elementor-form-submissions-in-google-analytics-events-using-jquery/). That event appears in community write-ups, not in Elementor’s own developer docs, so treat it as useful but unofficial and check it on your version.

![Flow diagram: visitor submits via AJAX, Elementor validates, actions run, new_record hook runs, then calls GA4, Meta and Google Ads, with a browser Pixel event sharing the same event_id](https://traculo.com/elementor-form-tracking-meta-google-ads/data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201200%20600'%3E%3C/svg%3E)

The server path runs inside the same AJAX request. The browser Pixel event fires separately and must carry the same event_id.

## What about Elementor’s Meta Pixel integration?

Elementor’s help center has an article titled “Add Facebook Pixel to Elementor”. Search summaries of it describe adding the pixel through Elementor’s Custom Code feature. The article body could not be read when we fetched it (only the navigation loaded), so we cannot confirm that Elementor sends a form-specific Lead event on its own. What we could verify is that a pixel snippet gives you PageView and whatever events you add yourself. Form events remain your job. If you rely on a built-in form event, open the Meta Test Events tool and submit a form to see what actually arrives.

## The server-side hook: where to attach your code

Elementor’s [forms hooks reference](https://developers.elementor.com/docs/hooks/forms) documents the server-side sequence:

- `elementor_pro/forms/validation` runs after the POST, with the record and the AJAX handler as arguments. You call `add_error()` on the handler to reject a submission.
- `elementor_pro/forms/process` runs once field validation has finished.
- `elementor_pro/forms/new_record` runs “after the form actions have run”. Its documented example reads `$record->get( 'fields' )` and posts the values to an external endpoint with `wp_remote_post()`.
- `elementor_pro/forms/webhooks/response` receives the response of the built-in Webhook action.

There is a second route: a custom form action. Elementor’s [form actions documentation](https://developers.elementor.com/docs/form-actions/) shows a class that extends `\ElementorPro\Modules\Forms\Classes\Action_Base`, implements `get_name()`, `get_label()`, `register_settings_section()`, `on_export()` and `run( $record, $ajax_handler )`, and is registered on the `elementor_pro/forms/actions/register` hook. The result is a new entry in the form’s Actions After Submit list, so an editor can switch it on per form without touching code. The documented example is a “ping” that calls an external server from `run()`.

Which to use? A `new_record` hook is shorter and fine for one site. A custom action is better for agencies: it shows up in the UI, you can add settings for pixel IDs, and non-developers can see which forms send data. Elementor’s docs do not state what happens to `new_record` if an earlier action fails, so test your failure cases rather than assume.

### One hook, three platforms

This sketch reads the record, checks consent, and sends a lead to GA4 and Meta. Google Ads comes later, for a reason explained below. Names and endpoints follow the documented hook and the platform docs; field IDs, IDs and secrets are placeholders.

```
add_action( 'elementor_pro/forms/new_record', function ( $record, $handler ) {
	if ( 'Quote request' !== $record->get_form_settings( 'form_name' ) ) {
		return;
	}

	$f = [];
	foreach ( $record->get( 'fields' ) as $id => $field ) {
		$f[ $id ] = $field['value'];
	}

	// 1. Always keep the lead and its click IDs (your CRM or a custom table).
	my_store_lead( $f );

	// 2. Only talk to ad platforms if the visitor allowed it.
	if ( ( $f['consent_marketing'] ?? '' ) !== 'granted' ) {
		return;
	}

	$event_id = sanitize_text_field( $f['event_id'] ?? wp_generate_uuid4() );

	// GA4 Measurement Protocol
	wp_remote_post(
		'https://www.google-analytics.com/mp/collect?measurement_id=G-XXXX&api_secret=SECRET',
		[ 'timeout' => 5, 'body' => wp_json_encode( [
			'client_id' => $f['ga_client_id'],
			'events'    => [ [ 'name' => 'generate_lead',
				'params' => [ 'form_name' => 'Quote request', 'campaign' => $f['utm_campaign'] ?? '' ] ] ],
		] ) ]
	);

	// Meta Conversions API
	wp_remote_post(
		'https://graph.facebook.com/vXX.X/PIXEL_ID/events?access_token=TOKEN',
		[ 'timeout' => 5, 'headers' => [ 'Content-Type' => 'application/json' ],
		  'body' => wp_json_encode( [ 'data' => [ [
			'event_name'       => 'Lead',
			'event_time'       => time(),
			'event_id'         => $event_id,
			'action_source'    => 'website',
			'event_source_url' => $f['page_url'] ?? home_url( '/' ),
			'user_data'        => [
				'em'                => [ hash( 'sha256', strtolower( trim( $f['email'] ) ) ) ],
				'fbc'               => $f['fbc'] ?? null,
				'fbp'               => $f['fbp'] ?? null,
				'client_ip_address' => $_SERVER['REMOTE_ADDR'] ?? null,
				'client_user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? null,
			],
		] ] ] ) ]
	);
}, 10, 2 );
```

Three details worth pointing out. First, the endpoint format, required fields and the recommendation to include `event_id` come from Meta’s [Using the API](https://developers.facebook.com/documentation/ads-commerce/conversions-api/using-the-api) page, and `Lead` is one of the [standard events](https://developers.facebook.com/documentation/meta-pixel/reference) with optional value and currency. Second, the GA4 endpoint needs a `client_id`, a `measurement_id` and an `api_secret`, per the [Measurement Protocol reference](https://developers.google.com/analytics/devguides/collection/protocol/ga4/reference); since the server cannot read the visitor’s browser, you pass the client ID in a hidden field. Third, `wp_remote_post()` blocks the AJAX response until it returns. A five second timeout keeps a slow platform from freezing the form; for busy sites, queue the calls with WP-Cron or Action Scheduler and log each response. Our [Meta Conversions API for WordPress guide](https://traculo.com/meta-conversions-api-for-wordpress/) covers hashing and required parameters in more depth.

### Why Google Ads is different

Google Ads does not want a “form was submitted” ping from your server. It wants the click ID back, tied to an outcome. For a lead-generation site the outcome you care about is usually not the submission but the qualified lead, days later. Google’s [import guidelines](https://support.google.com/google-ads/answer/15081888) say uploads more than 90 days after the click are not imported, and enhanced-conversions-for-leads uploads more than 63 days after. So the form hook’s job for Google Ads is to *store* the `gclid` (and `gbraid` or `wbraid`) with the lead. A second step, run when the lead is marked qualified in your CRM, performs the upload. The full pattern, with timestamp formats and error handling, is in our [Google Ads offline conversions guide](https://traculo.com/google-ads-offline-conversions-wordpress/), and the three IDs are explained in [GCLID, GBRAID and WBRAID](https://traculo.com/gclid-gbraid-wbraid-explained/).

## Hidden fields: how the click gets into the record

Elementor’s form widget has a **Hidden** field type, and each field has a custom ID. The hook above reads `$f['gclid']` because a field with the ID `gclid` exists. The submission record is keyed by those IDs, which is why naming them consistently on every form matters. Add these to each form:

![Diagram: landing URL with gclid and UTMs, a first-party cookie, then hidden Elementor fields mapped to Google Ads, CRM labels, Meta matching, dedup and consent](https://traculo.com/elementor-form-tracking-meta-google-ads/data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201200%20600'%3E%3C/svg%3E)

The landing page URL is the only place the click ID exists. The hidden fields carry it to the moment of submission.

- `gclid`, `gbraid`, `wbraid` for Google Ads.
- `utm_source`, `utm_medium`, `utm_campaign` so each lead keeps its campaign.
- `fbc` and `fbp`, the Meta browser values, if you are sending them with the lead.
- `ga_client_id` for the GA4 call.
- `event_id` and `consent_marketing`, covered below.
- `page_url`, for Meta’s required source URL.

How do you fill them? Elementor’s Academy documents a dynamic Request Parameter feature for passing visitor information, such as pre-populating forms, and some UTM tools add their own dynamic tags. These read the URL at page render. If your page is cached, that render happened once, for someone else, so the value can be wrong or empty. Elementor’s pages do not say how its Request Parameter tag behaves under page caching, so test it. The more reliable pattern is a small script that reads the URL and a first-party cookie in the visitor’s browser and sets the field values just before submission. The script from our [offline conversions post](https://traculo.com/google-ads-offline-conversions-wordpress/) stores the IDs in a cookie; extend it to fill the fields:

```
document.addEventListener('DOMContentLoaded', function () {
  const get = n => (document.cookie.match('(?:^|; )' + n + '=([^;]*)') || []) [1];
  document.querySelectorAll('.elementor-form').forEach(function (form) {
    ['gclid','gbraid','wbraid','utm_source','utm_medium','utm_campaign'].forEach(function (k) {
      const el = form.querySelector('[name="form_fields[' + k + ']"]');
      if (el && get('tr_' + k)) el.value = decodeURIComponent(get('tr_' + k));
    });
  });
});
```

The selector `form_fields[ID]` is the input naming Elementor Pro typically uses, but it is not stated in the docs reviewed here, so inspect your own form in the browser to confirm before relying on it. Elementor popups render forms later than the page load, so run the same fill when the popup opens, not only on `DOMContentLoaded`.

## Sharing one event_id with the browser

If you send a Lead from the browser Pixel and from the server, Meta needs to know they are one event. Per Meta’s [deduplication documentation](https://developers.facebook.com/documentation/ads-commerce/conversions-api/deduplicate-pixel-and-server-events), the Pixel `eventID` must match the server `event_id`, the event names must match, and events are only deduplicated if received within 48 hours of the first one. We explain the failure cases in [Meta CAPI deduplication, event_id explained](https://traculo.com/meta-conversions-api-deduplication-event-id/).

On an Elementor form the clean trick is to generate the ID in the browser and put it in the hidden `event_id` field before submission. The same value then exists in the page (for the Pixel) and in the record (for the server):

```
// On load and after each success, give the form a fresh ID
function newId(form) {
  const el = form.querySelector('[name="form_fields[event_id]"]');
  if (el) el.value = crypto.randomUUID();
}
// Browser event, when your success listener fires:
fbq('track', 'Lead', {}, { eventID: form.querySelector('[name="form_fields[event_id]"]').value });
```

Generating the ID in JavaScript sidesteps page caching, because it never comes from the cached HTML. Regenerate it after a successful submit so a second submission from the same page is a new event.

## Consent

Whatever sends data must respect the visitor’s choice. The sketch above checks a `consent_marketing` hidden field that your consent banner script sets to `granted`. Two rules keep this honest: the browser Pixel must not fire without the same consent, and the server hook must skip the ad platforms when the flag is missing, not only when it says “denied”. Storing the lead in your own system is a separate decision from sending it to Meta or Google. Our posts on [Consent Mode v2 on WordPress](https://traculo.com/consent-mode-v2-wordpress/) and [whether server-side tracking bypasses consent](https://traculo.com/does-server-side-tracking-bypass-consent/) go into the details. This post is not legal advice.

## Comparing the four approaches

![Table comparing thank-you page, GTM listener, GA4-only plugin and server-side hook on redirect need, platform reach, data for matching and upkeep](https://traculo.com/elementor-form-tracking-meta-google-ads/data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201200%20600'%3E%3C/svg%3E)

None of these is wrong. They answer different questions, and the right one depends on which platforms need the lead.

A **thank-you page** is the oldest method and still sound: tags fire on a real URL, and the *Redirect* action is built in. Its limits are one page per form and the fact that the page only knows what is in the URL. A **GTM listener** removes the redirect but adds a container, a trigger and tags to maintain, and everything runs in the browser. A **GA4-only plugin**, as in the MonsterInsights guide, has the lowest effort and covers GA4. The **server-side hook** has the most upkeep, since it is code you own, but it is the only option here that sees the whole record at once and can send it to every platform from one place. See [client-side vs server-side tracking](https://traculo.com/client-side-vs-server-side-tracking-in-wordpress/) for the trade-offs in general.

## What breaks

### Cached pages

Page caching serves the same HTML to everyone. Any hidden-field value rendered into that HTML, including a nonce-style event ID, is frozen for every visitor. Fill fields in the browser after load, as above, and test by loading a cached URL in a private window. See also [why WordPress analytics data goes missing](https://traculo.com/wordpress-analytics-data-missing/).

### Popup forms

Elementor can open a popup after a form is submitted, and a form can sit inside a popup. The popup’s form markup may not exist when your fill script runs, so hidden fields are empty. A form in a popup should submit through the same AJAX flow, so a thank-you page trigger is no more reliable there; confirm on your setup. Run the fill at popup open and test the popup separately from the page form.

### Duplicate submissions

Visitors double-click. Use the `event_id` as a lock: if the record already has a stored lead with that ID, do not send again.

### Timeouts and silent failures

If your hook ignores a platform error, the visitor still sees the success message. Log the HTTP status and response body for every call, and alert on repeated failures. Without logs, a broken access token looks identical to a quiet week.

### Webhook-only setups

Sending the form to Zapier or Make with the built-in Webhook action works for CRMs, but it moves the platform calls into a tool that does not know the browser’s `event_id` unless you pass it along. Include the hidden fields in the payload.

## Test it

![Checklist of eight tests: landing with a test gclid, hidden fields filled, cached page, popup form, GA4 events, Meta Test Events, declined consent, Google Ads diagnostics](https://traculo.com/elementor-form-tracking-meta-google-ads/data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%201200%20600'%3E%3C/svg%3E)

Run these in order. The first four prove the data reaches the record; the last four prove the platforms accept it.

1. Visit your landing page with `?gclid=test123&utm_campaign=test` and inspect the form. The hidden fields should hold those values.
2. Submit the form and open the record in Elementor’s submissions, or your CRM. The values must be there.
3. In GA4, confirm one lead event with your parameters (the Realtime report is the quick check). To validate payloads before sending, see [GA4 Measurement Protocol limits](https://traculo.com/ga4-measurement-protocol-limits/).
4. Add a `test_event_code` from Meta’s Test Events tab to the payload, submit again, and check that the browser and server events appear as one deduplicated event.
5. Decline consent and submit. Nothing should reach any platform.
6. Repeat steps 1 to 5 from a popup form and from a page that has been cached.
7. For Google Ads, check the upload diagnostics after a few hours. Google’s help says imported statistics can take around three hours to appear.

## Where Traculo fits

Traculo is a web app with a WordPress plugin that forwards events from its servers to GA4 (Measurement Protocol), Meta Conversions API, Google Ads offline conversions and other platforms, and keeps a delivery log with each integration’s response. It also has funnels and goals with Pageview or Event steps. Its plugin hooks Elementor Pro Forms on the server, after Elementor has accepted the submission. Forms built with other tools are covered only if that plugin is on its supported list, so check the event list on a test submission before relying on it. If you would rather not maintain a hook and three payloads, that is the problem it targets, and our [guide to tracking form submissions server-side](https://traculo.com/track-form-submissions-wordpress-server-side/) compares the options across form plugins.

## Frequently asked questions

### Does Elementor Pro send form events to Meta or Google Ads by itself?

Not as far as the documentation shows. Elementor documents form actions such as Email, Redirect and Webhook, and its help center has an article on adding the Facebook Pixel. We found no documented form-specific Lead or Google Ads conversion action. Add the event yourself, with a thank-you page tag, a browser listener, or a server hook.

### Which Elementor hook should I use for tracking?

`elementor_pro/forms/new_record` runs after the form actions have completed and gives you the record. Use `validation` only to reject bad input. If you want the option visible in the form’s Actions After Submit list, build a custom action instead.

### Do I need Google Tag Manager for Elementor forms?

No. A plugin can send GA4 events without it, as MonsterInsights’ guide shows, and a server hook can reach Meta and Google Ads directly. GTM remains useful if you already run a container and want everything in one place.

### How do I track Elementor popup forms?

The server hook should work the same way, because the popup uses the same form widget; confirm with a test submission. The hard part is hidden fields: fill them when the popup opens, not only on page load.

### Can I avoid double counting between the Pixel and the Conversions API?

Yes, by sending the same `event_id` and event name from both. Generate the ID in the browser into a hidden field so the page and the server hook see the same value.

## Related reading

- [WooCommerce server-side tracking: purchases, refunds, subscriptions](https://traculo.com/woocommerce-server-side-tracking/)
- [Track form submissions in WordPress: CF7, WPForms, Gravity Forms](https://traculo.com/track-form-submissions-wordpress-server-side/)
- [Why Meta, Google and GA4 never match your WooCommerce orders](https://traculo.com/ad-platforms-report-more-conversions-than-woocommerce/)
- [Meta Conversions API for WordPress: the complete guide](https://traculo.com/meta-conversions-api-for-wordpress/)
- [Meta CAPI deduplication, event_id explained](https://traculo.com/meta-conversions-api-deduplication-event-id/)
- [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/)
- [Server-Side Tracking for WordPress: a beginner’s guide](https://traculo.com/server-side-tracking-for-wordpress/)

If you want conversions from forms and the rest of your site in one place, with funnels and a delivery log for each integration, see Traculo’s [goals, conversions and funnels](https://traculo.com/goals-conversions-funnels/) and the [integrations](https://traculo.com/integrations/) it forwards to.

Share

[LinkedIn](https://www.linkedin.com/sharing/share-offsite/?url=https://traculo.com/elementor-form-tracking-meta-google-ads/) [X](https://x.com/intent/tweet?url=https://traculo.com/elementor-form-tracking-meta-google-ads/&text=Elementor%20form%20tracking%20beyond%20GA4:%20Meta%20and%20Google%20Ads) [Email](mailto:?subject=Elementor%20form%20tracking%20beyond%20GA4:%20Meta%20and%20Google%20Ads&body=https://traculo.com/elementor-form-tracking-meta-google-ads/)

- [Elementor](https://traculo.com/tag/elementor/)
- [Forms](https://traculo.com/tag/forms/)
- [GA4](https://traculo.com/tag/ga4/)
- [Google Ads](https://traculo.com/tag/google-ads/)
- [Hidden fields](https://traculo.com/tag/hidden-fields/)
- [Lead generation](https://traculo.com/tag/lead-generation/)
- [Meta Conversions API](https://traculo.com/tag/meta-conversions-api/)

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/elementor-form-tracking-meta-google-ads/
