Skip to main content

Google Analytics 4 — Event Streaming

The Kameleoon Google Analytics 4 Event Streaming integration lets you automatically send events to your Google Analytics 4 account whenever visitors are exposed to a Kameleoon experiment. This feature allows for enriched analytics in Google Analytics 4, providing insights on experiment exposure to help you better understand user behavior and engagement.

This integration uses Kameleoon's event dispatcher to send server side events to your Google Analytics 4 account in batches using the /batch endpoint of the Google Analytics 4 HTTP API.

Key benefits​

  • Precise behavior insights: The integration sends specific events to third-party tools for visitors exposed to web experiments and feature flags on SDK-based project. This detailed tracking provides a clear view of how different variations impact user actions. For example, you can observe which variation drives more clicks, conversions, or other desired outcomes, helping you determine the most effective approach.
  • Real-time decision-making: The integration provides data in real time. With these up-to-date insights, you can swiftly adjust strategies if a variation isn't performing as expected or allocate resources to capitalize on successful variations.
  • Effortless setup: Enable third-party integrations in the Kameloon app with no need for custom code or SDK changes.

Considerations​

Event delivery timing: Kameleoon's server dispatches events to Google Analytics 4 with a minimum 30-minute delay.

Prerequisites​

To configure this integration, you need the following information:

  • Kameleoon SDK: An SDK must be installed on your server-side project.
  • API secret: The API secret generated in Google Analytics, documented here.
  • Measurement ID: For web SDKs, the identifier for a Data Stream, as documented here.
  • Firebase app ID: For mobile SDKs, the identifier for a Firebase app, as documented here.

Choosing the right GA4 identifier​

To ensure proper user attribution in GA4 reports, you must create the correct custom data depending on the app type:

  • For web-based projects (websites using gtag.js): Create a custom data called ga4_client_id and retrieve the client_id from GA4 (typically stored in the _ga cookie).
  • For Firebase-based mobile apps: Create a custom data called ga4_app_instance_id and retrieve the app_instance_id from the Firebase SDK.

This distinction applies to all types of GA4 integrations in Kameleoon, whether for web experiments or feature flag experiments.

Setup​

This integration can be used for web and feature experimentation.

For Web experiments​

Enable the integration on the Integration page.

Identify GA4 client ID​

You must send an instance identifier to the Kameleoon backend on each visit. The exact identifier depends on your GA4 setup. If you're using GA4 with the gtag.js method, send the client_id. Below is an example of a gtat.js implementation using our Activation API.

Set up the Custom data​

  • Name: ga4_client_id
  • Select your project.
  • Retrieval method: Kameleoon Activation API.
  • Type: Single
  • Format: String
  • Scope: Visit

Add code in the Global script​

// first create a ga4ClientId variable and obtain your GA4 client id
let gaClientId = null;

gtag('get', 'G-XXXXXXXXXX', 'client_id', function(clientId) {
  gaClientId = clientId;
  console.log('GA4 Client ID:', gaClientId);
});

// then set your Kameleoon "ga_client_id" custom data to this value with our Activation API
Kameleoon.API.Data.setCustomData("ga4_client_id", ga4ClientId);

Activate the integration for your campaigns​

Add the integration while finalizing your web experiment.

For Feature experiments​

Set up the integration in the feature flag environment under the Integrations section. Enable it for each environment where you want it to be active.

For Mobile​

If you're using GA4 analytics with a Firebase app, you must send the Firebase app instance ID.

Here's an example with the Kameleoon Android SDK:

  1. Identify GA4 Firebase app instance ID
  2. Set up a Custom data
    • Name: ga_app_instance_id
    • Select your project.
    • Retrieval method: Kameleoon SDK method.
    • Type: Single
    • Format: String
    • Scope: Visit

Java example using the Kameleoon Android SDK​

First, get your Firebase app instance ID and store it in a variable.

Next, use the Kameleoon SDK to set your ga4_app_instance_id custom data to this value, making sure to use the correct index for the ga4_app_instance_id custom data, which you can find in the Kameleoon interface.

In this example, the index is 12:

kameleoonClient.addData(new CustomData(12, appInstanceId));

Once the integration is active and your experiment is live, Kameleoon will begin sending experiment events to Google Analytics 4 whenever a visitor is exposed. These events are built according to Google's recommended best practices. These events include key details such as:

  • A unique identifier for the Firebase app instance, for SDK setup only, called app_instance_id.
  • A unique identifier for the client, for Web setup only, called client_id.
  • Exposure time
  • A unique identifier for the experiment and variation that follow the format KAM-XXXX-YYYY, where XXXX is the Kameleoon experiment ID and YYYY is the variation ID.

Event payload example​

Kameleoon sends events to Google Analytics 4 in the following format:

{
  "events": [
    {
      "name": "experience_impression",
      "exp_variant_string": "KAM-1234-5567",
      "timestamp_micros": 1718201234000
    },
    {
      "name": "experience_impression",
      "exp_variant_string": "KAM-5678-6978",
      "timestamp_micros": 1718201267000
    }
  ],
  "app_instance_id": "example-instance-id"
}

Note that any custom data specific to your business, typically included in your Google Analytics 4 events, will not be present in the events sent by Kameleoon from the server. If you need to enrich the payload with data not tracked natively by Kameleoon, you can submit a feature request.