Skip to main content
In some cases you might want to forward events that pagent tracks to your own tooling. For this purpose, you can setup an event listener on the pagent:event bus on the window object and receive all events that pagent is tracking or creating. Here is an example: 
<script>
  window.addEventListener('pagent:event', (e) => {
      console.log("pagent:event", e.detail);
  });
</script>
Note: If no session is active, pagent will not emit any events on the pagent:event bus.

​
Event types

Below is an overview of all event kinds that pagent emits.
Event kindDescription
clickFired whenever the visitor clicks anywhere on the page.
page_viewFired each time a page is loaded or navigated to.
opt_inFired when the visitor explicitly opts-in to tracking.
opt_outFired when the visitor opts-out of tracking.
conversionFired when a conversion goal is recorded.
session_startFired the moment a new session begins.
session_endFired when the current session is terminated.
errorFired whenever an error occurs while running pagent.
highlight_textFired when pagent highlights text on the page.
element_viewFired when a tracked element scrolls into the viewport.
hoverFired when the visitor hovers over a tracked element.
session_pingSent periodically while a session is active to keep it alive.

​
Common properties

The following attributes are included in every event:
PropertyTypeDescription
session_idstringUnique identifier of the current session.
visit_idstringUnique identifier of the current page view.
timenumberUnix timestamp in milliseconds when the event occurred.
is_uniqueboolean (optional)true if this is the first time this event type was emitted during the session.
is_opted_inbooleanIndicates whether the visitor has opted-in to tracking.
session_durationnumberSession duration in milliseconds at the moment the event was emitted.
scroll_depthnumberMaximum vertical scroll position in pixels that the visitor has reached so far.
scroll_percentagenumberPercentage of the page that has been scrolled.
urlstringAbsolute URL of the page where the event happened.

​
session_start properties

The session_start event is the one that carries the visitor’s experiment context. When the visitor is enrolled in a running test, it includes the following additional properties (alongside the common properties above):
PropertyTypeDescription
experiment_idstring (optional)The experiment UUID.
experiment_numeric_idnumber (optional)The sequential test number shown in the pagent dashboard as “Test #N” (for example, 27). Useful for building human-readable names.
variation_idstring (optional)UUID of the variation assigned to this visitor.
is_controlboolean (optional)true if the visitor is in the control group, false if in a variant.
endpoint_idstring (optional)UUID of the targeted endpoint.
endpoint_pathstring (optional)The path the test is configured to target, for example /pricing. For tests targeting a URL pattern (glob), this may be the pattern rather than the exact visited URL.
cohort_idstring (optional)UUID of the cohort the visitor belongs to.
cohort_versionnumber (optional)Version of the cohort definition.
Note: All of these experiment fields are absent (or null) when there is no active pagent test on the current page — for example analytics-only sessions or visitors not enrolled in any running test. Always check event.experiment_id before reading the others, as the JENTIS example below does.

​
Example integration

You can also forward individual pagent events to other analytics platforms. The following example shows how to send the conversion event to JENTIS using its push-based data layer: 
<script>
  // Keep track of the current session
  let session = null;

  // Forward pagent "conversion" events to the JENTIS data layer
  window.addEventListener('pagent:event', (e) => {
    const event = e.detail;

    // Store the session start event in case we are running an experiment
    if (event.kind === 'session_start' && event.experiment_id) {
      session = event;
      return;
    }

    // Only track conversions for active experiments
    if (!session || event.kind !== "conversion") return;

    // Prepare the JENTIS queue (it as a simple array on window)
    window._jts = window._jts || [];

    // Push the event object itself
    _jts.push({
      track: 'event', // JENTIS track command
      group: 'generic', // optional grouping
      context: 'pagent', // helps to identify the source
      kind: 'conversion', // helps to identify the event type
      experiment_id: session.experiment_id, // unique identifier of the experiment
      variation_id: session.variation_id, // unique identifier of the variation
      cohort_id: session.cohort_id, // unique identifier of the cohort
      is_control: session.is_control // whether the displayed variation is control
    });

    // Finally submit everything to JENTIS
    _jts.push({ track: 'submit' });
  });
</script>
This keeps your implementation lightweight. You only need to listen for pagent events and decide which ones you want to forward. The example above listens exclusively for the conversion event and immediately submits it to JENTIS.