OpenCart + CleverTap Integration for Retargeting Based on User Behavior

Standard

CleverTap is a powerful customer engagement platform that supports push notifications, email, SMS, and in-app messagingβ€”ideal for user segmentation and retargeting. Integrating CleverTap with OpenCart allows merchants to track behavioral events, build dynamic audiences, and automate retargeting campaigns across channels.

🧰 Prerequisites

Requirement Description
OpenCart 3.x or 4.x Your eCommerce platform
GTM Web Container Installed on all OpenCart pages
CleverTap Account With Web SDK credentials and App ID
Consent Management Optional but recommended for compliance


🎯 Targeted Events for Retargeting

Event Name Trigger Source Purpose
Product Viewed Product Detail Page Browsing intent
Add to Cart Add Button Click High intent behavior
Begin Checkout Checkout Entry Funnel drop-off detection
Purchase Order Confirmation Conversion and LTV analysis

These will power behavioral segments in CleverTap (e.g., cart abandoners, product viewers with no checkout).


πŸ“¦ Step 1: Install CleverTap Web SDK via GTM

Create a new GTM tag:

  • Tag Type: Custom HTML
  • Trigger: All Pages

<script type="text/javascript">
var clevertap = {
event:[],
profile:[],
account:[],
onUserLogin:[],
notifications:[],
privacy:[]
};

clevertap.account.push({"id": "YOUR_ACCOUNT_ID"});
clevertap.privacy.push({optOut: false});
clevertap.privacy.push({useIP: true});

(function () {
var wzrk = document.createElement('script');
wzrk.type = 'text/javascript';
wzrk.async = true;
wzrk.src = 'https://cdn.clevertap.com/js/clevertap.min.js';
var s = document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(wzrk, s);
})();
</script>

βœ… Replace "YOUR_ACCOUNT_ID" with your actual CleverTap account ID.


πŸ›’ Step 2: Inject DataLayer Events in OpenCart Templates

A. Product Detail Page (product.twig)

<script>
window.dataLayer = window.dataLayer || [];
dataLayer.push({
event: 'product_viewed',
product_id: '{{ product_id }}',
product_name: '{{ heading_title }}',
category: '{{ category }}',
price: '{{ price }}'
});
</script>

B. Cart Add Event (add to cart click handler or cart.twig)

dataLayer.push({
event: 'add_to_cart',
product_id: '123',
product_name: 'Product Name',
price: 19.99
});

C. Checkout Start (checkout.twig)

<script>
dataLayer.push({ event: 'begin_checkout' });
</script>

D. Order Success Page (success.twig)

<script>
dataLayer.push({
event: 'purchase',
transaction_id: '{{ order_id }}',
revenue: {{ order_total }},
currency: '{{ currency }}',
user_email: '{{ email | lower }}',
user_id: '{{ customer_id }}'
});
</script>


🌐 Step 3: Fire CleverTap Events from GTM

A. Product Viewed

Trigger: Custom Event = product_viewed

<script>
clevertap.event.push("Product Viewed", {
"Product ID": "{{DL - product_id}}",
"Product Name": "{{DL - product_name}}",
"Category": "{{DL - category}}",
"Price": "{{DL - price}}"
});
</script>

B. Add to Cart

Trigger: Custom Event = add_to_cart

<script>
clevertap.event.push("Add to Cart", {
"Product ID": "{{DL - product_id}}",
"Price": "{{DL - price}}"
});
</script>

C. Checkout Started

Trigger: Custom Event = begin_checkout

<script>
clevertap.event.push("Begin Checkout", {});
</script>

D. Purchase

Trigger: Custom Event = purchase

<script>
clevertap.event.push("Purchase", {
"Transaction ID": "{{DL - transaction_id}}",
"Revenue": "{{DL - revenue}}",
"Currency": "{{DL - currency}}"
});
</script>


πŸ‘€ Step 4: Identify Users via Login or Purchase

Use clevertap.onUserLogin to attribute behavior to specific users:

Trigger: On login or purchase

<script>
clevertap.onUserLogin.push({
"Site": {
"Email": "{{DL - user_email}}",
"Identity": "{{DL - user_id}}"
}
});
</script>


πŸ” Step 5: Consent-Aware Tag Execution (Optional)

Wrap your GTM tag or use GTM’s Consent Mode:

<script>
if (window.consent_granted === true) {
clevertap.event.push("Product Viewed", {...});
}
</script>


πŸ“Š Step 6: Use CleverTap Segments for Retargeting

Create Behavioral Segments in CleverTap:

  • Users who viewed product but didn’t purchase in 3 days
  • Users who started checkout but didn’t complete
  • Users who made 2+ purchases in last 7 days

Use these segments to trigger:

  • Push notifications
  • WhatsApp/SMS campaigns
  • Email retargeting
  • In-app messages (for hybrid OpenCart apps)


πŸ§ͺ Step 7: QA & Debug

Tool Purpose
GTM Preview Mode Ensure correct event triggers
Clarity Console Check clevertap.event.push() logs
CleverTap Dashboard Verify event ingestion and segment logic


Microsoft Clarity Setup for OpenCart with Event-Based Filters via GTM

Standard

Microsoft Clarity is a free behavioral analytics tool offering session recordings, heatmaps, rage click detection, and powerful filters. In this tutorial, you’ll learn how to integrate Clarity into OpenCart via Google Tag Manager (GTM), and enhance it with event-based filters like product views, add-to-cart actions, and checkout initiations.

🧰 Prerequisites

Requirement Description
OpenCart (v3.x/4.x) Your eCommerce platform
GTM Web Container Installed on OpenCart
Microsoft Clarity Project ID from clarity.microsoft.com
Consent Banner (Optional) GDPR/CCPA compliance


🎯 What You’ll Achieve

  • Full session recording and heatmaps on OpenCart
  • Tag sessions with custom events (e.g., “purchase”, “view_product”)
  • Filter recordings by user interactions
  • Respect consent with conditional loading


πŸ“¦ Step 1: Get Your Clarity Project ID

  1. Sign in at clarity.microsoft.com
  2. Create a new project (site)
  3. Copy the Project ID from the installation instructions


🌐 Step 2: Add Microsoft Clarity Script via GTM

In your GTM Web Container:

  • Tag Type: Custom HTML
  • Trigger: All Pages (or conditional based on consent)

<script type="text/javascript">
(function(c,l,a,r,i,t,y){
c[a]=c[a]||function(){(c[a].q=c[a].q||[]).push(arguments)};
t=l.createElement(r);t.async=1;t.src="https://www.clarity.ms/tag/"+i;
y=l.getElementsByTagName(r)[0];y.parentNode.insertBefore(t,y);
})(window, document, "clarity", "script", "YOUR_CLARITY_PROJECT_ID");
</script>

βœ… Replace YOUR_CLARITY_PROJECT_ID with your actual Clarity ID.


πŸ” Step 3: Consent-Based Loading (Optional)

To respect privacy regulations, use GTM consent triggers or wrap your script:

<script>
if (window.consent_granted === true) {
(function(c,l,a,r,i,t,y){
c[a]=c[a]||function(){(c[a].q=c[a].q||[]).push(arguments)};
t=l.createElement(r);t.async=1;t.src="https://www.clarity.ms/tag/"+i;
y=l.getElementsByTagName(r)[0];y.parentNode.insertBefore(t,y);
})(window, document, "clarity", "script", "YOUR_CLARITY_PROJECT_ID");
}
</script>

Or use GTM’s built-in Consent Mode and enable only after "analytics_storage" is granted.


πŸ›’ Step 4: Push Custom DataLayer Events in OpenCart

Add these in appropriate .twig templates:

A. Product Detail Page

In product.twig:

<script>
window.dataLayer = window.dataLayer || [];
dataLayer.push({
event: 'product_viewed',
product_id: '{{ product_id }}',
product_name: '{{ heading_title }}',
category: '{{ category }}'
});
</script>

B. Add to Cart Event

In your cart button JS handler or via click listener:

dataLayer.push({
event: 'add_to_cart',
product_id: '{{ product_id }}',
price: '{{ price }}'
});

C. Checkout Start

In checkout.twig:

<script>
dataLayer.push({
event: 'checkout_started'
});
</script>


🎯 Step 5: Fire Clarity Custom Events via GTM

Example: Tag Product View Sessions

  • Trigger: Custom Event = product_viewed
  • Tag Type: Custom HTML

<script>
clarity("set", "product_viewed", true);
</script>

Repeat for:

  • add_to_cart β†’ clarity("set", "add_to_cart", true)
  • checkout_started β†’ clarity("set", "checkout_started", true)
  • purchase_complete β†’ clarity("set", "purchase", true)

You can also push metadata:

<script>
clarity("set", "cart_value", "{{DL - cart_total}}");
</script>


πŸ”Ž Step 6: Filter Recordings by Custom Tags

After custom tags are pushed:

  1. Go to Clarity > Recordings
  2. Use the Filter by Custom Tags
    • Example: product_viewed, checkout_started
  3. Combine filters with Device, Browser, Page, or Country


πŸ§ͺ Step 7: Test & Debug

Tool Purpose
GTM Preview Confirm triggers and tag fire
Clarity Dashboard View incoming sessions and tags
Clarity Debug Tool Use browser DevTools > Network tab

You should see https://www.clarity.ms/tag/ load and custom events appear.


πŸ“ˆ Bonus: Funnel Insights with Clarity

Use Clarity’s Filters + Heatmaps to evaluate:

Funnel Stage Filter Tag Use
Product Browsing product_viewed Scroll/click depth on PDP
Intent add_to_cart Rage clicks on add buttons
Conversion Flow checkout_started Drop-off points in checkout
Post-Purchase purchase Survey triggers


Tracking User Sessions & Heatmaps in OpenCart with Hotjar

Standard

Hotjar provides visual behavior analytics like session recordings, heatmaps, and user feedback tools. Integrating Hotjar into OpenCart helps you analyze how users interact with your product pages, cart flow, and checkout stepsβ€”offering key insights to boost conversions and reduce drop-offs.

🧰 Prerequisites

Item Description
OpenCart 3.x or 4.x Store platform
Google Tag Manager For deployment and trigger control
Hotjar Site ID Available from your Hotjar dashboard
Consent Banner Required for GDPR/CCPA compliance


🎯 Objective

  • Record visitor sessions
  • Generate heatmaps for PDP, cart, and checkout
  • Enable feedback polls or surveys
  • Use GTM for granular control and triggering


πŸ“¦ Step 1: Get Your Hotjar Site ID

  1. Log into https://insights.hotjar.com
  2. Create or select your OpenCart site
  3. Copy your unique Hotjar Site ID


🌐 Step 2: Add Hotjar Script in GTM

Create a new GTM tag:

  • Tag Type: Custom HTML
  • Trigger: All Pages (or conditional triggers after consent)

<!-- Hotjar Tracking Code -->
<script>
(function(h,o,t,j,a,r){
h.hj=h.hj||function(){(h.hj.q=h.hj.q||[]).push(arguments)};
h._hjSettings={hjid: YOUR_HOTJAR_ID, hjsv:6};
a=o.getElementsByTagName('head')[0];
r=o.createElement('script');r.async=1;
r.src=t+h._hjSettings.hjid+j+h._hjSettings.hjsv;
a.appendChild(r);
})(window,document,'https://static.hotjar.com/c/hotjar-','.js?sv=');
</script>

βœ… Replace YOUR_HOTJAR_ID with your Hotjar Site ID.


πŸ” Step 3: Consent-Only Execution (Optional but Recommended)

Wrap the tag in a GTM Consent Initialization Trigger or use a custom variable:

<script>
if (window.consent_granted === true) {
(function(h,o,t,j,a,r){
h.hj=h.hj||function(){(h.hj.q=h.hj.q||[]).push(arguments)};
h._hjSettings={hjid: YOUR_HOTJAR_ID, hjsv:6};
a=o.getElementsByTagName('head')[0];
r=o.createElement('script');r.async=1;
r.src=t+h._hjSettings.hjid+j+h._hjSettings.hjsv;
a.appendChild(r);
})(window,document,'https://static.hotjar.com/c/hotjar-','.js?sv=');
}
</script>

Or configure GTM Consent Settings:

  • Enable "ad_storage" or "analytics_storage" before tag fires.


πŸ›’ Step 4: Set Up Triggers for Key Page Types

Instead of firing Hotjar on all pages, fire only on key funnel steps:

Trigger Name URL Path Condition Use
Product View Page Page Path contains /product Heatmaps + session replay
Cart Page Page Path is /index.php?route=checkout/cart Behavior before checkout
Checkout Page Page Path contains /checkout Funnel abandonment cues
Success Page Page Path contains /success Post-conversion analysis

You can also use custom event triggers for finer control.


πŸ‘οΈ Step 5: Add Custom Hotjar Events (Optional)

Use hj('event', 'name') to tag sessions.

Example: Track Checkout Start

In checkout.twig:

<script>
if (typeof hj === "function") {
hj('event', 'checkout_started');
}
</script>

Use these in GTM tags too:

<script>
hj('event', 'product_viewed');
</script>

Then use the Hotjar filters to isolate sessions containing those events.


πŸ’¬ Step 6: Trigger Feedback Polls on Key Pages

Example: Show survey after purchase

<script>
if (typeof hj === "function") {
hj('trigger', 'purchase_feedback');
}
</script>

Then configure a Hotjar Survey to appear only for the purchase_feedback trigger.


πŸ§ͺ Step 7: Debug Your Setup

Tool Use
GTM Preview Ensure tag and trigger activation
Hotjar Site Dashboard Confirm data is being received
Hotjar Live View Watch real-time sessions


🎯 Strategic Benefits

  • Visualize clicks, scrolls, drop-offs
  • Learn why users abandon cart or checkout
  • Collect user feedback on product pages
  • Understand session replay behavior


OpenCart + Heap Analytics: Tracking the Full Customer Journey via GTM

Standard

Heap Analytics offers automatic data capture and advanced journey mapping. Integrating Heap with OpenCart via Google Tag Manager (GTM) allows merchants to track and enrich user actions like product views, add-to-carts, and purchasesβ€”without needing custom event tracking per page.

🧰 Prerequisites

Requirement Description
OpenCart 3.x/4.x E-commerce platform
GTM Web Container Installed and publishing
Heap App ID From your Heap project
Consent Management Recommended for GDPR/CCPA compliance


🎯 Key Events to Track in Heap

Event Name Trigger Location
Product Viewed Product Detail Page
Add to Cart Add Button Click
Checkout Started Checkout Page
Purchase Completed Order Success Page
User Identified Any login or checkout step


πŸ“¦ Step 1: Add Heap Analytics Base Script via GTM

Create a GTM Web tag:

  • Tag Type: Custom HTML
  • Trigger: All Pages

<script type="text/javascript">
window.heap=window.heap||[],heap.load=function(e,t){
window.heap.appid=e,window.heap.config=t=t||{};
var r=document.createElement("script");
r.type="text/javascript",r.async=!0,
r.src="https://cdn.heapanalytics.com/js/heap-"+e+".js";
var a=document.getElementsByTagName("script")[0];
a.parentNode.insertBefore(r,a);
};
heap.load("YOUR_HEAP_APP_ID");
</script>

βœ… Replace YOUR_HEAP_APP_ID with your project’s App ID.


πŸ›’ Step 2: Push Events from OpenCart Templates

A. Purchase Event on Success Page

In catalog/view/theme/*/template/checkout/success.twig:

<script>
window.dataLayer = window.dataLayer || [];
dataLayer.push({
event: 'purchase_completed',
transaction_id: '{{ order_id }}',
revenue: {{ order_total }},
currency: '{{ currency }}',
email: '{{ email | lower | sha256 }}',
user_id: '{{ customer_id }}'
});
</script>

B. Product View Event on Product Page

In product.twig:

<script>
dataLayer = dataLayer || [];
dataLayer.push({
event: 'product_viewed',
product_id: '{{ product_id }}',
product_name: '{{ heading_title }}',
price: '{{ price }}',
category: '{{ category }}'
});
</script>


🌐 Step 3: Manual Heap Events via GTM Tags

Create Custom HTML Tags in GTM for each key event.

1. Product Viewed

Trigger: Custom Event = product_viewed

<script>
heap.track("Product Viewed", {
product_id: '{{DL - product_id}}',
name: '{{DL - product_name}}',
price: '{{DL - price}}',
category: '{{DL - category}}'
});
</script>

2. Add to Cart

Trigger: Click on Add to Cart button (e.g. CSS selector trigger)

<script>
heap.track("Add to Cart", {
product_id: '{{DL - product_id}}',
price: '{{DL - price}}'
});
</script>

3. Checkout Started

Trigger: Page Path contains /checkout

<script>
heap.track("Checkout Started", {
cart_value: '{{DL - cart_total}}',
item_count: '{{DL - item_count}}'
});
</script>

4. Purchase Completed

Trigger: Custom Event = purchase_completed

<script>
heap.track("Purchase Completed", {
transaction_id: '{{DL - transaction_id}}',
revenue: '{{DL - revenue}}',
currency: '{{DL - currency}}'
});
</script>


πŸ‘€ Step 4: Identify Users for Cross-Session Attribution

Use heap.identify() to tie activity to a user.

Trigger: Pageview after login or on checkout page:

<script>
heap.identify('{{DL - user_id}}');
heap.addUserProperties({
email: '{{DL - email}}'
});
</script>

Note: Email should be hashed client-side or handled server-side via consent validation.


πŸ” Step 5: Consent-Aware Event Firing

Use a consent_granted variable in GTM and wrap your tags:

<script>
if (window.consent_granted === true) {
heap.track("Event Name", { ... });
}
</script>

Or apply GTM’s built-in Consent Mode configuration to block tags.


πŸ§ͺ Step 6: QA & Validation

Tool Purpose
GTM Preview Mode Ensure events and variables work
Heap Live View Real-time view of tracked events
Browser Console Debug heap.track() invocations

You can also enable Heap’s Event Visualizer for automatic property capture.


🎯 Strategic Benefits

  • Visualize full customer journey from PDP to checkout
  • Enable cohort and funnel analysis
  • Support cross-device tracking via heap.identify()
  • Enhanced custom property collection via GTM variables


Amplitude Tracking for E-commerce Behavior in OpenCart

Standard

Amplitude Analytics empowers product and growth teams to analyze user behavior at scale. Integrating Amplitude with OpenCart allows merchants to track granular e-commerce actions such as product views, cart additions, checkouts, and purchasesβ€”all with high fidelity.

🧰 Prerequisites

Requirement Purpose
OpenCart (v3.x or 4.x) E-commerce platform
Google Tag Manager Client-side tag deployment
Amplitude API Key For event tracking
Consent Handling Optional, for GDPR/CCPA compliance

🎯 Goal

Track the following events in Amplitude from OpenCart:

Event Name Trigger Location
Product Viewed Product detail page
Add to Cart Add to cart button click
Begin Checkout Checkout initiation
Purchase Order success page

Each event will include user ID, product data, value, and currency.


πŸ“¦ Step 1: Install Amplitude JS SDK via GTM

Create a tag in your GTM Web Container:

  • Tag Type: Custom HTML

  • Trigger: All Pages

<script type="text/javascript">
(
function(e,t){var n=e.amplitude||{_q:[],_iq:{}};var r=t.createElement("script");
r.type="text/javascript";r.async=true;
r.src="https://cdn.amplitude.com/libs/amplitude-8.12.0-min.gz.js";
r.onload=function(){if(e.amplitude.runQueuedFunctions){
e.amplitude.runQueuedFunctions()}else{
console.log("[Amplitude] Error loading")}};
var i=t.getElementsByTagName("script")[0];i.parentNode.insertBefore(r,i);
function s(e,t){e.prototype[t]=function(){
this._q.push([t].concat(Array.prototype.slice.call(arguments,0)));return this}}
var o=function(){this._q=[];return this};
var a=["add","append","clearAll","prepend","set","setOnce","unset"];
for(var c=0;c<a.length;c++){s(o,a[c])}n.Identify=o;
n.getInstance=function(e){e=(!e || e.length===0 ? "$default_instance" : e);
if(!n._iq.hasOwnProperty(e)){n._iq[e]={_q:[]};for(var t=0;t<a.length;t++){
s(n._iq[e],a[t])}}return n._iq[e]};e.amplitude=n})
(window,document);
amplitude.getInstance().init(“YOUR_API_KEY”);
</script>

Replace YOUR_API_KEY with your Amplitude project API key.


πŸ›’ Step 2: Push Events via OpenCart DataLayer

Inject dynamic data from OpenCart into the dataLayer. For example, in catalog/view/theme/*/template/checkout/success.twig:

<script>
window.dataLayer = window.dataLayer || [];
dataLayer.push({
event: 'purchase',
transaction_id: '{{ order_id }}',
revenue: {{ order_total }},
currency: '{{ currency }}',
email: '{{ email | lower | sha256 }}',
user_id: '{{ customer_id }}'
});
</script>

Repeat similar structures for:

  • Product View (product.twig)

  • Add to Cart (via JS listener on add-to-cart button)

  • Begin Checkout (checkout.twig)


🌐 Step 3: GTM Tags for Each Event

πŸ”Ή Product Viewed

Trigger: Page Path contains /product/

Tag (Custom HTML):

<script>
amplitude.
getInstance().identify(new amplitude.Identify().set('user_id', '{{DL - user_id}}'));
amplitude.getInstance().logEvent("Product Viewed", {
product_id: '{{DL - product_id}}',
product_name: '{{DL - product_name}}',
category: '{{DL - category}}',
price: '{{DL - price}}'
});
</script>

πŸ”Ή Add to Cart

Use a click trigger on the Add to Cart button.

<script>
amplitude.
getInstance().logEvent("Add to Cart", {
product_id: '{{DL - product_id}}',
price: '{{DL - price}}'
});
</script>

πŸ”Ή Begin Checkout

Trigger: Page path contains /checkout

html
<script>
amplitude.
getInstance().logEvent("Begin Checkout", {
cart_value: '{{DL - cart_total}}',
item_count: '{{DL - item_count}}'
});
</script>

πŸ”Ή Purchase

Trigger: Custom Event = purchase

<script>
amplitude.
getInstance().identify(new amplitude.Identify().set('user_id', '{{DL - user_id}}'));
amplitude.getInstance().logEvent("Purchase", {
transaction_id: '{{DL - transaction_id}}',
revenue: '{{DL - revenue}}',
currency: '{{DL - currency}}',
email: '{{DL - email}}'
});
</script>

πŸ” Consent Handling

If GDPR/CCPA applies, wrap your Amplitude tags in conditional logic:

if (window.consent_granted === true) {
amplitude.getInstance().logEvent("Event Name", {...});
}

Or, use GTM’s built-in Consent Mode to block tags until ad_storage or analytics_storage is granted.


πŸ§ͺ Debugging

Tool Purpose
GTM Preview Mode Validate variables and triggers
Amplitude Debug Enable via browser dev console: localStorage.setItem('amplitude_debug', true)
Amplitude UI View real-time event stream

🧠 Strategic Tips

  • Use identify() with user_id to enable cross-device journey analysis.

  • Track refund events via server-side GTM and send to Amplitude’s HTTP API if needed.

  • Enable Amplitude’s cohort exports to ad platforms using the Segment or mParticle bridge.


πŸ“Š Funnel Events Summary

Event Location Purpose
Product Viewed PDP Template Engagement stage
Add to Cart Button Click Intent stage
Begin Checkout Checkout Entry Decision stage
Purchase Order Success Page Conversion + Revenue tracking

OpenCart to Mixpanel Event Mapping via GTM for Customer Funnel Insights

Standard

Mapping OpenCart events to Mixpanel using Google Tag Manager provides granular insight into your eCommerce customer funnelβ€”from product view to checkout. This setup enables precise user journey analysis and advanced segmentation.


🧰 Prerequisites

  • OpenCart (v3.x or 4.x)
  • Google Tag Manager (Web container)
  • Mixpanel project token
  • SHA-256 hashing (for PII)


πŸ“¦ Step 1: Install Mixpanel Base Script via GTM

GTM Web > New Tag

  • Tag Type: Custom HTML
  • Trigger: All Pages

<script type="text/javascript">
(function(f,b){if(!b.__SV){var a,e,i,g;window.mixpanel=b;b._i=[];
b.init=function(a,e,d){function f(b,h){var a=h.split(".");
2==a.length&&(b=b[a[0]],h=a[1]);b[h]=function(){b.push([h].concat(
Array.prototype.slice.call(arguments,0)))}}var c=b;"undefined"!==
typeof d?c=b[d]=[]:d="mixpanel";c.people=c.people||[];c.toString=function(b){
var a="mixpanel";"mixpanel"!==d&&(a+="."+d);b||(a+=" (stub)");return a};
c.people.toString=function(){return c.toString(1)+".people (stub)"};
i="disable time_event track track_pageview track_links track_forms register register_once alias unregister identify name_tag set_config reset people.set people.set_once people.unset people.increment people.append people.union people.track_charge people.clear_charges people.delete_user".split(" ");
for(g=0;g<i.length;g++)f(c,i[g]);b._i.push([a,e,d])};
b.__SV=1.2;a=f.createElement("script");a.type="text/javascript";
a.async=!0;a.src="https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js";
e=f.getElementsByTagName("script")[0];e.parentNode.insertBefore(a,e)}})(document,window.mixpanel||[]);

mixpanel.init("YOUR_MIXPANEL_TOKEN");
mixpanel.track("Page View");
</script>


πŸ›’ Step 2: Push Events from OpenCart Templates

Add the following to success.twig for order confirmation:

<script>
dataLayer = dataLayer || [];
dataLayer.push({
  event: 'purchase',
  user_id: '{{ customer_id }}',
  transaction_id: '{{ order_id }}',
  revenue: {{ order_total }},
  currency: '{{ currency }}',
  email: '{{ email | lower | sha256 }}'
});
</script>

Similarly, push add_to_cart, view_item, begin_checkout events in respective .twig templates or via JS listeners.


🌐 Step 3: GTM Tags for Funnel Events

Create GTM tags (Custom HTML) for each funnel step with respective triggers:

Example: Purchase Event

<script>
mixpanel.identify('{{DL - user_id}}');
mixpanel.track('Purchase', {
  transaction_id: '{{DL - transaction_id}}',
  revenue: '{{DL - revenue}}',
  currency: '{{DL - currency}}',
  email: '{{DL - email}}'
});
</script>

Example: Add to Cart

<script>
mixpanel.track('Add to Cart', {
  product_id: '{{DL - product_id}}',
  price: '{{DL - price}}'
});
</script>


πŸ“Œ Key Events to Track

Event Name Trigger Point
Page View All Pages
View Item Product Detail Page
Add to Cart On Click of Add Button
Begin Checkout Checkout Initiation Page
Purchase Order Success Page


πŸ” Consent Management

Ensure dataLayer events and Mixpanel scripts only run after consent. Use a consent_granted variable in GTM.


πŸ§ͺ Debug & QA Tools

Tool Use Case
GTM Preview Check variable injection
Mixpanel Debugger Live event stream
Browser Console Verify track() invocations


🎯 Strategic Value

  • Full-funnel visibility in Mixpanel
  • Enhanced segmentation using product/category-level events
  • Cross-session and cross-device tracking with identify()


Facebook Ads Enhanced Conversion Tracking Strategy in OpenCart

Standard

Enhanced Conversions enable you to send first-party customer data (like email and phone) to Facebook, improving match rates and attribution accuracy. This is especially critical for OpenCart stores where conversions may happen post-login or via redirects.


🧰 Prerequisites

  • OpenCart (v3.x/4.x)
  • Facebook Pixel and CAPI access
  • GTM Web + Server Containers
  • Consent mechanism (GDPR/CCPA compliant)
  • SHA-256 hashing support

🧱 Step 1: Add Facebook Pixel with Enhanced Conversion Signals

  1. GTM Web > New Tag > Custom HTML
  2. Trigger: All Pages
<script>
  !function(f,b,e,v,n,t,s)
  {if(f.fbq)return;n=f.fbq=function(){n.callMethod?
  n.callMethod.apply(n,arguments):n.queue.push(arguments)};
  if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0';
  n.queue=[];t=b.createElement(e);t.async=!0;
  t.src=v;s=b.getElementsByTagName(e)[0];
  s.parentNode.insertBefore(t,s)}(window, document,'script',
  'https://connect.facebook.net/en_US/fbevents.js');

  fbq('init', 'YOUR_PIXEL_ID', {
    em: '{{user_email}}',
    ph: '{{user_phone}}'
  });
  fbq('track', 'PageView');
</script>

πŸ“₯ Step 2: Collect Email & Phone in Data Layer

Edit catalog/view/theme/YOUR_THEME/template/checkout/success.twig:

<script>
  dataLayer = dataLayer || [];
  dataLayer.push({
    event: 'purchase',
    event_id: 'fb_{{ order_id }}',
    transaction_id: '{{ order_id }}',
    value: {{ order_total }},
    currency: '{{ currency }}',
    user_email: '{{ email | lower | sha256 }}',
    user_phone: '{{ phone | regex_replace('/\D/', '') | sha256 }}'
  });
</script>

🌐 Step 3: Trigger Server Event from Web GTM

GTM Web > New Custom HTML tag

  • Trigger: purchase
<script>
fetch('https://gtm.yourdomain.com/event', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    event_name: 'Purchase',
    event_id: '{{DL - event_id}}',
    transaction_id: '{{DL - transaction_id}}',
    value: '{{DL - value}}',
    currency: '{{DL - currency}}',
    email: '{{DL - user_email}}',
    phone: '{{DL - user_phone}}'
  })
});
</script>

πŸ“‘ Step 4: Send Enhanced Conversions via CAPI

In GTM Server:

  1. Trigger: event_name = Purchase
  2. Tag: HTTP Request
POST https://graph.facebook.com/v18.0/YOUR_PIXEL_ID/events?access_token=ACCESS_TOKEN
{
  "data": [{
    "event_name": "Purchase",
    "event_time": {{timestamp}},
    "event_id": "{{event_id}}",
    "action_source": "website",
    "user_data": {
      "em": "{{email}}",
      "ph": "{{phone}}"
    },
    "custom_data": {
      "currency": "{{currency}}",
      "value": {{value}},
      "transaction_id": "{{transaction_id}}"
    }
  }]
}

πŸ” Step 5: Deduplication

  • Keep event_id consistent between browser and server events.
  • Facebook deduplicates events using this ID.

πŸ” Step 6: Consent Logic

Use a consent_granted variable to delay dataLayer push and tag triggers. Ensure only compliant users are tracked.


πŸ§ͺ Step 7: QA & Debugging

Tool Purpose
GTM Preview Mode Inspect variables and tag firing
Facebook Events Manager Check Enhanced Conversions match quality
Chrome Dev Tools Validate network request payloads

🎯 Strategic Notes

  • Improved match rates = better ROAS
  • Helps fill attribution gaps from iOS/blocked environments
  • Consent-friendly and future-ready

Setting Up Pinterest Conversion API for OpenCart with Product Catalog Events

Standard

Pinterest Conversion API (CAPI) enables direct server-side tracking of conversion events. Combined with product catalog events from OpenCart, this setup enhances signal quality and supports dynamic retargeting and shopping campaigns.


🧰 Prerequisites

  • OpenCart store with product catalog
  • GTM Web + Server containers configured
  • Pinterest Business account with Tag ID and CAPI Token
  • Product ID mapping in OpenCart
  • HTTPS domain and consent layer

🧱 Step 1: Add Pinterest Tag in GTM Web (Client-Side)

  1. Tag Type: Custom HTML
  2. Trigger: All Pages
<script>
!function(e){if(!window.pintrk){window.pintrk = function () {
window.pintrk.queue.push(Array.prototype.slice.call(arguments))};
var n=window.pintrk;n.queue=[],n.version="3.0";
var t=document.createElement("script");t.async=!0,
t.src=e;var r=document.getElementsByTagName("script")[0];
r.parentNode.insertBefore(t,r)}}("https://s.pinimg.com/ct/core.js");

pintrk('load', 'YOUR_TAG_ID');
pintrk('page');
</script>
<noscript>
<img height="1" width="1" style="display:none;" alt=""
src="https://ct.pinterest.com/v3/?event=init&tid=YOUR_TAG_ID" />
</noscript>

πŸ›’ Step 2: Push Purchase Event with Product Data

In success.twig:

<script>
dataLayer = dataLayer || [];
dataLayer.push({
  event: 'purchase',
  event_id: 'pin_{{ order_id }}',
  transaction_id: '{{ order_id }}',
  value: {{ order_total }},
  currency: '{{ currency }}',
  line_items: [
    {% for product in products %}
    {
      product_id: '{{ product.model }}',
      product_name: '{{ product.name }}',
      quantity: {{ product.quantity }},
      price: {{ product.price }}
    },
    {% endfor %}
  ],
  email: '{{ email | lower | sha256 }}',
  phone: '{{ phone | regex_replace('/\D/', '') | sha256 }}'
});
</script>

🌐 Step 3: Send Payload to GTM Server via Web Tag

GTM Web β†’ New Tag β†’ Custom HTML β†’ Trigger: purchase

<script>
fetch('https://gtm.yourdomain.com/event', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    event_name: 'checkout',
    event_id: '{{DL - event_id}}',
    transaction_id: '{{DL - transaction_id}}',
    value: '{{DL - value}}',
    currency: '{{DL - currency}}',
    line_items: {{DL - line_items}},
    email: '{{DL - email}}',
    phone: '{{DL - phone}}'
  })
});
</script>

πŸ“‘ Step 4: Configure Pinterest CAPI in GTM Server

  1. Trigger: event_name equals checkout
  2. Tag Type: HTTP Request
POST https://api.pinterest.com/v5/events
Authorization: Bearer YOUR_CAPI_TOKEN
Content-Type: application/json

{
  "event_name": "checkout",
  "event_time": {{timestamp}},
  "action_source": "website",
  "event_id": "{{event_id}}",
  "user_data": {
    "em": "{{email}}",
    "ph": "{{phone}}"
  },
  "custom_data": {
    "currency": "{{currency}}",
    "value": {{value}},
    "order_id": "{{transaction_id}}",
    "contents": {{line_items}}
  }
}

πŸ” Step 5: Match With Pinterest Catalog

  • Ensure product_id matches the product feed ID used in Pinterest Ads
  • This enables dynamic product ads and retargeting

πŸ” Step 6: GDPR Consent Handling

  • Ensure server-side firing occurs only after consent
  • Gate GTM tag triggers using a consent_granted variable

πŸ§ͺ Step 7: QA & Debugging

Tool Use
GTM Preview Inspect Web + Server events
Pinterest Events Manager Monitor checkout events in real-time
Dev Tools Console Validate Data Layer and network payloads

Snapchat Pixel + CAPI Implementation for OpenCart Product Sales

Standard

 

Snapchat CAPI (Conversions API) improves conversion measurement accuracy and reliability in OpenCart by enabling server-side event transmission. This setup combines both browser-based Pixel tracking and server-side CAPI via GTM Server.


🧰 Prerequisites

  • OpenCart 3.x/4.x site
  • GTM Web + Server Containers
  • Snapchat Business Manager (Pixel ID + CAPI Token)
  • HTTPS-enabled site
  • Email and phone hashing logic (SHA-256)

🧱 Step 1: Install Snapchat Pixel in GTM Web

  1. Open GTM Web > New Tag
  2. Tag Type: Custom HTML
  3. Trigger: All Pages
<!-- Snapchat Pixel Base Code -->
<script type="text/javascript">
  (function(w,d,s,u,n,a,m){w['SnapPixelObject']=n;w[n]=w[n]||function(){
  (w[n].q=w[n].q||[]).push(arguments)};a=d.createElement(s);
  m=d.getElementsByTagName(s)[0];a.async=1;a.src=u;m.parentNode.insertBefore(a,m);
  })(window,document,'script','https://sc-static.net/scevent.min.js','snaptr');

  snaptr('init', 'YOUR_PIXEL_ID');
  snaptr('track', 'PAGE_VIEW');
</script>

πŸ’³ Step 2: Push Purchase Event from OpenCart

In success.twig after order placement:

<script>
dataLayer = dataLayer || [];
dataLayer.push({
  event: 'purchase',
  transaction_id: '{{ order_id }}',
  value: {{ order_total }},
  currency: '{{ currency }}',
  email: '{{ email | lower | sha256 }}',
  phone: '{{ phone | regex_replace('/\D/', '') | sha256 }}',
  event_id: 'sc_{{ order_id }}'
});
</script>

🌐 Step 3: Send Data to Server via GTM Web Tag

Create a Custom HTML tag:

  • Trigger: Event equals purchase
<script>
fetch('https://gtm.yourdomain.com/event', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    event_name: 'PURCHASE',
    event_id: '{{DL - event_id}}',
    transaction_id: '{{DL - transaction_id}}',
    currency: '{{DL - currency}}',
    value: '{{DL - value}}',
    email: '{{DL - email}}',
    phone: '{{DL - phone}}'
  })
});
</script>

πŸ“‘ Step 4: Create Snapchat CAPI Tag in GTM Server

  1. Trigger: event_name equals PURCHASE
  2. Tag Type: HTTP Request
POST https://tr.snapchat.com/v2/conversion
{
  "pixel_id": "YOUR_PIXEL_ID",
  "event_type": "PURCHASE",
  "event_conversion_type": "WEB",
  "timestamp": {{timestamp}},
  "event_tag": "purchase_event",
  "user": {
    "email": "{{email}}",
    "phone": "{{phone}}"
  },
  "price": {{value}},
  "currency": "{{currency}}",
  "event_id": "{{event_id}}"
}

πŸ” Step 5: Deduplication Logic

  • Use a consistent event_id across both pixel and server event
  • Snapchat handles deduplication using this field

πŸ” Step 6: Consent Control

Implement CMP logic to fire server + pixel tracking only after consent is granted.


πŸ§ͺ Step 7: Testing & Debugging

Platform Tool
GTM Preview (Web + Server)
Snapchat Ads Events Manager
Browser Console Verify network + pixel call

 

OpenCart TikTok Conversion API Server-Side Tracking Using GTM

Standard

Implementing TikTok Conversion API (Events API) through Server-Side GTM ensures reliable conversion tracking even if the browser is restricted by ad blockers or iOS limitations. This setup in OpenCart allows for higher accuracy and enhanced campaign attribution.


🧰 Prerequisites

  • OpenCart 3.x or 4.x
  • TikTok Business Account with Pixel ID and Access Token
  • GTM Web and Server Containers
  • HTTPS domain
  • Consent solution (GDPR/CCPA)


🧱 Step 1: Install TikTok Pixel in GTM (Web)

  1. Go to GTM Web > New Tag
  2. Tag Type: Custom HTML
  3. Trigger: All Pages

<!-- TikTok Pixel Base Code -->
<script>
!function (w, d, t) {
  w.TiktokAnalyticsObject = t;
  var ttq = w[t] = w[t] || [];
  ttq.methods = ["page","track"],
  ttq.setAndDefer = function (t, e) {
    t[e] = function () {
      t.push([e].concat(Array.prototype.slice.call(arguments, 0)))
    }
  };
  for (var i = 0; i < ttq.methods.length; i++) ttq.setAndDefer(ttq, ttq.methods[i]);
  ttq.load = function (e) {
    var n = d.createElement("script");
    n.async = !0;
    n.src = "https://analytics.tiktok.com/i18n/pixel/events.js?sdkid=" + e;
    var a = d.getElementsByTagName("script")[0];
    a.parentNode.insertBefore(n, a)
  };
  ttq.load('YOUR_PIXEL_ID');
  ttq.page();
}(window, document, 'ttq');
</script>


πŸ’³ Step 2: Data Layer Push on Purchase (success.twig)

<script>
dataLayer = dataLayer || [];
dataLayer.push({
  event: 'purchase',
  transaction_id: '{{ order_id }}',
  value: {{ order_total }},
  currency: '{{ currency }}',
  contents: [{% for product in products %}
    {
      id: '{{ product.model }}',
      name: '{{ product.name }}',
      quantity: {{ product.quantity }},
      price: {{ product.price }}
    },
  {% endfor %}],
  email: '{{ email | lower | sha256 }}',
  phone: '{{ phone | regex_replace('/\D/', '') | sha256 }}',
  event_id: 'tt_{{ order_id }}'
});
</script>


🌐 Step 3: Send Payload to Server via Web GTM

Create a Custom HTML tag:

  • Trigger: purchase

<script>
fetch('https://gtm.yourdomain.com/event', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    event_name: 'CompletePayment',
    event_id: '{{DL - event_id}}',
    transaction_id: '{{DL - transaction_id}}',
    currency: '{{DL - currency}}',
    value: '{{DL - value}}',
    contents: {{DL - contents}},
    email: '{{DL - email}}',
    phone: '{{DL - phone}}'
  })
});
</script>


πŸ“‘ Step 4: TikTok Events API Setup in Server GTM

In Server GTM:

  1. Trigger: Custom event = CompletePayment
  2. Tag Type: HTTP Request

POST https://business-api.tiktok.com/open_api/v1.2/pixel/track/
{
  "pixel_code": "YOUR_PIXEL_ID",
  "event": "CompletePayment",
  "event_id": "{{event_id}}",
  "timestamp": {{timestamp}},
  "properties": {
    "contents": {{contents}},
    "currency": "{{currency}}",
    "value": "{{value}}",
    "order_id": "{{transaction_id}}",
    "user": {
      "email": "{{email}}",
      "phone_number": "{{phone}}"
    }
  }
}


πŸ” Step 5: Deduplication & Attribution

Ensure both client-side TikTok pixel and server event share the same event_id.


πŸ” Step 6: Consent Compliance

Use consent_granted variable to ensure tracking only fires after user grants consent.


πŸ§ͺ Step 7: Debugging

Tool Purpose
TikTok Events Manager Validate pixel + server events
GTM Preview Mode Inspect server + web payloads
Browser Dev Tools Verify network requests