Worker routingif (dir === 'csp-reports') {
  remote = "https://collect-eu-central-1.tealiumiq.com/integration/event/services-caleb/csp-violations/iuxe4s"
}

Worker header injection// Create a new Headers object to modify response headers
const newHeaders = new Headers(response.headers);
 
// Reuse previously sent Content-Security-Policy
if (originalResponse.status !== 304) {
  // 'strict-dynamic' removes the need for nonce propagation
  newHeaders.set("content-security-policy",
    `default-src 'self'; style-src https://calebjaquith.com 'unsafe-inline'; img-src https://calebjaquith.com https://*.cdninstagram.com data:; script-src 'nonce-${nonce}' 'unsafe-eval' 'strict-dynamic'; report-uri https://calebjaquith.com/fwd-csp-reports/report;`);
  newHeaders.set("content-security-policy-report-only",
    `default-src 'self' https://*.usercentrics.eu; style-src https://calebjaquith.com 'unsafe-inline'; img-src https://calebjaquith.com https://*.cdninstagram.com data:; script-src 'nonce-${nonce}' 'unsafe-eval' 'strict-dynamic'; report-uri https://calebjaquith.com/fwd-csp-reports/report;`);
}

The post Using Tealium for Content Security Policy (CSP) Reporting appeared first on Tealium.

Example first-party pathshttps://calebjaquith.com/fwd-tealcdn/libs/tealiumjs/latest/tealium_collect.min.js
https://calebjaquith.com/fwd-tealcdn/shared/tms/t.tealium_collect.1_0_3.js

utag_cfg_ovrdwindow.utag_cfg_ovrd = window.utag_cfg_ovrd || {};
window.utag_cfg_ovrd.utag_cdn_rewrite = 'lkjdf';

a.src = utag.cfg.path + ((typeof a.name != 'undefined') ? a.name : 'ut' + 'ag.' + a.id + '.js')

a.src = utag.cfg.path.replaceAll('utag', (utag.cfg.utag_cdn_rewrite||'utag')) + ((typeof a.name != 'undefined') ? a.name : (utag.cfg.utag_cdn_rewrite || 'utag') + '.' + a.id + '.js')

v = utag.cfg.path;
 
if (b["cp.utag_main__ss"] == 1 && !utag.cfg.no_session_count) utag.ut.loader({ src: v + "ut" + "ag" + ".v.js?a=" + utag.cfg.utid + (utag.cfg.nocookie ? "&nocookie=1" : "&cb=" + (new Date).getTime()), id: "tiqapp" })

Rewrite the billing call// CUSTOM - add support for rewriting the billing call
v = utag.cfg.path + "utag";
v = v.replaceAll('utag', (utag.cfg.utag_cdn_rewrite || 'utag'));
 
if (b["cp.utag_main__ss"] == 1 && !utag.cfg.no_session_count) utag.ut.loader({ src: v + ".v.js?a=" + utag.cfg.utid + (utag.cfg.nocookie ? "&nocookie=1" : "&cb=" + (new Date).getTime()), id: "tiqapp" })

The post Build first‑party durability with Cloudflare Workers appeared first on Tealium.

By integrating Tealium with Microsoft Fabric, organizations bridge the gap between real-time customer behavior and advanced analytical power. This integration doesn't just move data; it fuels Fabric’s AI with the high-fidelity, real-time context required to make intelligent decisions in the moment.

Why Tealium Context is the Best Fuel for Fabric AI

AI models, especially Large Language Models (LLMs) and Predictive ML, thrive on signal density and freshness. Standard data warehouse exports are often "cold," representing who the customer was yesterday. Tealium provides the "Live Signal":

• Eliminating the "Data Gap": Tealium captures signals and intent—like engagement patterns, category interests, and budget shifts—the moment they happen.
• High-Fidelity Inputs: Fabric’s AI models perform better when fed structured, real-time context (e.g., "User is currently browsing luxury villas") rather than raw, noisy logs.
• Session-Aware Intelligence: Tealium maintains the state of the current session, allowing Fabric to understand the sequence of events leading up to a prediction.

Visualizing the Intelligence Loop: Tealium → Fabric → Tealium

The Architectural Foundation: OneLake and Event House

To understand the integration, one must first understand the "categories" within Microsoft Fabric that support Tealium’s data streams:

• OneLake: The "OneDrive for data"—a centralized storage foundation where all data resides.
• Event House: The real-time powerhouse tailored for high-volume, high-velocity data. It uses KQL (Kusto Query Language) for lightning-fast querying of Tealium events.
• Data Factory & Notebooks: The engines used to transform and apply Machine Learning (ML) to the live data once it is inside the Fabric ecosystem.

How Data Flows from Tealium to Fabric

The integration begins at the edge. Tealium captures granular user behaviors and signals from any device and streams them through the Microsoft Fabric Event House Connector. By enabling "OneLake availability" on the KQL table, the data is mirrored into a Lakehouse in Delta format. This ensures the data is ready for AI indexing without the delay of traditional ETL. From here, data can be used for any application in Fabric, including AI workloads, and the processed data is then passed back to Tealium via API for activation across your organization's technology stack. 

Key Use Cases: From Collection to Intelligence

AI-Powered Search and Discovery (RAG)

By mirroring real-time contextual events from Tealium into a Lakehouse, data can be indexed by Azure AI Search for Retrieval-Augmented Generation (RAG).

• The Mechanism: A Fabric Notebook transforms Delta records into JSON objects for indexing.
• The Result: An AI agent provides personalized recommendations grounded strictly in the current interests captured by Tealium (e.g., "Show me trips matching the $3,000 budget I just searched for").

Predictive Marketing via Machine Learning

Instead of reacting to what a user did, businesses predict what they will do next.

• The Mechanism: Fabric Notebooks processes historical and real-time Tealium data to train custom ML models (e.g., "Next Best Destination").
• The Activation: Once a prediction is generated, Fabric sends it back to Tealium’s collections API endpoint. Tealium then triggers this insight across all downstream vendors (Email, DSPs, and Personalization tools).

The "Intelligent" Custom Agent

This is a closed-loop interaction where the AI feels truly "human" because it has the full context of the user's journey.

• The Interaction: A user engages with a chat interface.
• The Intelligence: An LLM extracts entities from the chat, while Fabric’s ML model processes those entities against the real-time contextual data flowing from Tealium.
• The Result: A highly accurate recommendation delivered in milliseconds, reflecting the user's most recent clicks.

Real-World Application: The "Next Best Action"

Consider a traveler who just browsed "Food and Culture" trips to Asia.

• Inside Fabric: The ML model analyzes the real-time interest and budget signals. It predicts the next best fit is Vienna via Lufthansa.
• Through Tealium: This prediction is instantly sent to the engagement layer.
• Multi-Channel Execution: 
  • Web: A personalized pop-up appears: "Welcome back! How about Vienna?"
  • Email: An automated email via any Email Service Provider (ESP) is sent, pre-populated with the predicted airline and destination.

Strategic Benefits of the Integration

The Future of the Intelligence Loop

The integration of Tealium and Microsoft Fabric turns a collection of fragmented touchpoints into a sophisticated data loop. By fueling Fabric’s analytical engines with Tealium’s real-time context, businesses move beyond reactive marketing and toward a future of true, AI-driven predictive intelligence.

Ready to set up the integration? Here are the developer docs for Microsoft Fabric Eventhouse Connector

The post The Intelligence Loop: Powering Microsoft Fabric AI with Tealium’s Real-Time Context appeared first on Tealium.

Imagine a customer buying an entire outfit, jeans, a shirt, a jacket, and shoes, from three different retailers, all within a single Gemini search prompt. With that level of convenience and ease of use, we expect this to become a preferred method of shopping faster than the industry can react. The reality is that brands must adapt to "Chat Checkout" today.

We’ve already seen this shift in the market; ChatGPT has already implemented native purchasing, and we should expect many more platforms to follow. The good news? Tealium is already there. We provide the same innovative framework used to track ChatGPT apps to seamlessly support this new frontier in Google Gemini, ensuring your brand is ready to turn AI searches into loyal customers.

The Tracking Challenge: Visibility in a Third-Party Interface

When a customer interacts with Gemini, they aren't on your traditional website. This creates a visibility gap for traditional client-side tracking (like GA4 or standard Pixels). Failing to track these "agentic" interactions creates a critical intelligence gap, resulting in a lack of insights and attribution and fragmented feedback loops that leave you blind to why a customer truly converts or drops off.

• In a Native Flow: The user stays entirely within Google’s UI. Your JavaScript never runs, creating a "black box" where you lose all funnel visibility.
• In an Embedded Flow: Your web checkout appears in an iframe. While your tags can run here, the funnel becomes "hybrid"—certain sensitive actions (like selecting a payment method in Google Wallet) happen in the host's native UI, invisible to your on-page code.

To get the full picture, you need a strategy that combines these signals with Google’s Universal Commerce Protocol (UCP). Tealium bridges this gap by supporting both integration paths:

1. Native Platform Checkout (Server-to-Server)

Tealium uses Server-Side APIs to ingest UCP events directly from your backend. We map UCP session states (create, update, complete) to your Tealium Events API, ensuring that Gemini purchases are attributed correctly in Tealium and delivered to your downstream vendor ecosystem.

2. Embedded Checkout (Hybrid Orchestration)

If you choose the "Embedded Protocol" path, your web-based checkout is shown via an iframe. This allows you to use Tealium iQ (Tag Management) for client-side signals while using UCP server events to "fill the gaps" where the host platform takes over the payment or fulfillment UI.

Beyond Tracking: Personalizing the "Agentic" Loop

Tracking tells you what happened; personalization dictates what will happen. The most exciting part of the Gemini integration is the ability to influence the AI's recommendations using Tealium Moments API.

Because Gemini utilizes UCP and the Model Context Protocol (MCP), it is designed to request "context" from a retailer before it displays search results. By inserting Tealium into that loop, you move from generic results to hyper-personalized commerce.

How the Personalization Flow Works

Instead of Gemini showing a generic list of "High-rise jeans," the process follows this sequence:

1. The Request: A user asks Gemini, "Show me some high-rise jeans."
2. Identity Linking: Gemini utilizes the UCP Identity Linking capability (via OAuth 2.0) to establish who the user is in your system.
3. The Context Fetch: Gemini calls your backend via the UCP/MCP tool endpoint (e.g., /search or /recommendations).
4. The Tealium Call: Your server immediately queries the Tealium Moments API using the linked Identity ID (anonymous or known).
5. The Real-Time Response: Tealium returns the user’s "Badges" and "Audiences" (e.g., Badge: Sustainable Shopper, Audience: Size 6, Preference: Recycled Denim).
6. The Reranking: Your backend uses this Tealium data to filter your product catalog before sending the structured content back to Gemini.
7. The Result: Gemini delivers a tailored response: "Based on your preference for size 6 and sustainable fabrics, here are the best high-rise options for you."

Adapting to the New Purchase Touchpoint

Gemini has created a new, frictionless touchpoint. However, a frictionless experience is wasted if it’s irrelevant. It is the responsibility of the modern retailer to ensure this new channel is integrated into the broader customer journey.

Our customers are already pushing the boundaries and innovating to take advantage of these new technologies. At Tealium, we are committed to making sure they have a partner who can adapt and innovate alongside them.

By leveraging Tealium for your Gemini integration, you bridge the gap between AI and human intent:

• Accurate Insights: You aren't "blind" to AI-driven conversions. You see the full customer journey, accurately stitching together chat interactions and final purchases.
• Brand Consistency: The customer who receives a "Frequent Shopper" or “Gold Loyalty Tier” discount on your website gets the same recognition inside Gemini, thanks to real-time identity resolution.

The future of commerce is conversational, but the engine of that conversation is data. Tealium provides the essential context that transforms a generic AI interaction into a personalized brand experience. With Tealium and UCP, you aren’t just following a trend—you’re ready to turn AI searches into loyal, lifelong customers.

Technical Summary for Implementation:

• Protocol: Universal Commerce Protocol (UCP) / Model Context Protocol (MCP).
• Identity: OAuth 2.0 Identity Linking (standard UCP capability).
• Tracking: Tealium Server-Side for Native; Hybrid Orchestration with Client+Server-side for Embedded.
• Personalization: Tealium Moments API (Low-latency identity enrichment).
• Data Layer: Mapping UCP checkout-sessions to standard Tealium e-commerce events (Purchase, AddToCart).

The post The Future of “Agentic” Commerce: Tracking and Personalizing the Gemini Purchase Experience appeared first on Tealium.

Modern browser privacy controls reduce invasive tracking, but they also shorten the lifetime of legitimate, consented first‑party cookies in Safari, sometimes purging them after about a week of inactivity. This causes repeat consent prompts and breaks returning‑user recognition. See Tracking Prevention in WebKit for details.  

This is annoying and costly, but it's especially important in opt‑out models like California’s CCPA, where site owners may be required to honor opt‑outs for extended periods and avoid unnecessary re‑prompting. If Safari removes the consent cookie because a user didn’t revisit in a given time window, you risk resuming tracking until they opt out again, an audit risk created by well‑intended built-in browser behavior. Even opt-in models like the GDPR require that you hang onto consent decisions and don't keep prompting, but that's only possible if you're able to retain the relevant cookies.

The right fix is to preserve the decision in a controlled, first‑party place that isn’t governed by the same browser lifetime rules. 

Why a first‑party reverse proxy is the right lever

At a high level, a proxy server acts as an intermediary for requests from clients seeking resources from other servers. Instead of connecting directly, the client connects to the proxy, which then forwards the request to the target server.

That means the proxy ensures that browsers talk to your domain first - a first-party reverse proxy can receive first-party requests from the browser, then forwards to Tealium services (and other trusted vendors) behind the scenes. That single shift unlocks durable cookie handling and governance, because the browser doesn't see the third-party servers working behind the scenes, unlocking durable cookies and governance opportunities. 

The pattern is as first‑party as it gets: run on your own domain and edge. It effectively negates any first-party features vendors deliver and shifts control to the site owner, with impressive long‑term benefits even though it requires build‑and‑maintain efforts.

• Durable consent and identity. Store server‑side copies of specific cookies and restore them client‑side only when appropriate. This mitigates first‑party lifetime limits (like Safari’s ITP) while respecting consent flows.
• Granular governance. Decide exactly which cookies to persist, for how long, and with what attributes. Remove or rewrite cookies (even HttpOnly cookies) that are set by proxied servers.
• First‑party routing for trusted services. Forward Tealium iQ, Tealium Collect, and Data Layer Enrichment (DLE) through your domain, which reduces exposure to browser limitations and some list‑based blocking patterns that key on subdomain.
• Additional ad‑block hardening options. Optionally rewrite browser‑visible paths to remove strings like “utag” and then restore them post-proxy so vendor origins still receive standard paths that the browser never sees, helping with even the most restrictive Adblock tools.
• Performance, control, and resilience. The edge is close to users and under your control. You can add small, targeted behaviors without waiting on vendor releases or incurring extra round trips. We easily added IP addresses into Tealium Collect payloads - the pattern gives you a flexible, first-party way to really control how your users are tracked and your cookies are persisted.

How it works

Generally, this is how a website looks, though this is an over-simplified  example - most modern sites have quite a few more sources of content than this.

Above, the only first-party files are the ones that come from the customer's own CDN - this is standard.

Adding a first-party reverse proxy lets a site owner use a set of first-party paths to act as a middleman between the browser and the third-party CDNs. 

With a reverse proxy, a first-party path (from the browser's perspective) can load a file that's hosted by a third party, with the ability to edit both the request and response as needed, without DNS or certificate updates.

Below, mysite.biz/fwd-teal-cdn/* will forward the requests and responses from the tags.tiqcdn.com/*, where * is any path on that subdomain (modifying request and response as appropriate).

That powerful approach allows you to make first-party requests to third party servers without each vendor needing to add features (or even know it's happening). It also allows the requests and responses to be edited as needed.

It also makes very useful patterns more accessible, like setting first-party http-only copies of critical cookies (this type of cookie isn't removed by Safari). Those cookies can be restored into client-side readable versions with each request, allowing you to preserve consent and identity beyond what Safari allows for client-side persistence, improving analytics, returning visitor recognition, attribution, consent decisions and more.

It also makes those requests first-party from the perspective of browser and adblocks by obfuscating the final URLs behind the reverse proxy, which can include any number of path rewrites as needed.

Should everything run through my shiny new reverse proxy?

No, actually - you'll notice that we left facetube.social requests third-party in the diagrams above. That's because that imaginary social site relies on third-party cookies to work correctly, which makes it incompatible with first-party tracking strategies (because third-party cookies rely on third-party requests).

(Much) more detail in the next post

This is the first in a set of posts - we will be publishing the full details of a working implementation of this kind of reverse proxy solution using Cloudflare Workers here: Build first‑party durability with Cloudflare Workers.

The post Reduce Consent Fatigue and Improve Compliance appeared first on Tealium.

Tealium CDP (AudienceStream) allows for configuration enabling randomized persistent visitor segmentation for A/B or multivariate testing directly within the platform.

By leveraging the Split String enrichment, organizations can use Tealium to assign visitors into Test and Control groups at the Visitor level and ensure those assignments persist across sessions.

Because Tealium automatically maintains a visitor ID for each device or browser - and merges known IDs through visitor stitching - these test/control group assignments remain stable across both authenticated and anonymous states, allowing for clean measurement and consistent audience targeting.

This guide outlines how to configure Visitor Attributes, Enrichments, Audiences, and Measurement strategies for A/B testing within AudienceStream.

Contents:

• Prerequisites - Visitor Identity Resolution, Stitching, & Profiling

• Simplified Attribute Setup

• Split String Enrichment Configuration

• Audience Definitions & Activation

• Implementation Considerations & Best Practices

Step 1: Prerequisites - Visitor Identity Resolution, Stitching, & Profiling

1. Before implementing A/B testing, ensure that visitor identification and data collection are properly configured in Tealium iQ Tags and AudienceStream CDP.
2. Tealium automatically assigns a visitor ID for each browser or device.
   https://docs.tealium.com/server-side/visitor-stitching/anonymous-user-visitor-id-attributes/#anonymous-id 
3. When authenticated identifiers (e.g., hashed email or CRM ID) are captured, Tealium merges visitor profiles using Visitor Stitching, ensuring continuity across devices and channels.
   https://docs.tealium.com/server-side/visitor-stitching/about/ 
4. With these mechanisms in place, a visitor’s A/B test group assignment will persist across sessions and visits (and across devices if stitched), maintaining deterministic group membership.

Step 2: Simplified Attribute Setup

To enable a simple A/B test configuration, we start by creating the following Attributes within Tealium CDP:

These attributes provide us with a simple and easy-to-understand foundation for segmenting visitors into test and control audiences and measuring test performance.

As you extend the behavior of your Tealium CDP visitor profiles and run different types of A/B tests, you may choose to set up different Attribute configurations to track those. 

Step 3: Split String Enrichment Configuration

The Split String enrichment allows you to assign visitors into groups based on a randomized distribution.

This enrichment is configured directly on the AB Test Group attribute and requires no source input or external randomization key. AudienceStream automatically handles randomization internally and assigns and persists the result at the Visitor level.

To configure:

1. Create or edit the Visitor String Attribute  AB Test Group.
2. Add a Split String enrichment to the attribute.
3. Keep the box checked Allow split to only occur once for given scope. 
4. Define the values and their distribution:
   • Control → 75%
   • Test → 25%
5. Save and publish your AudienceStream configuration.

How it works:

• The Split String enrichment runs once per visitor when their profile is created.
• Each visitor is randomly assigned to one of the defined values based on the configured distribution.
• Once assigned, the value is stored permanently on the visitor profile and persists across visits and sessions (and across devices if stitched).
• Tealium CDP’s built-in randomization logic ensures even distribution of group assignments over time.

Key considerations:

• You do not need to specify a “source attribute” or seed — randomization is handled internally by Tealium CDP.
• The Split String enrichment will not overwrite an existing group assignment unless you explicitly create an enrichment that resets the attribute.
• Early Test/Control distributions may show minor variance, but balance will normalize as audience size increases.

Step 4: Audience Definitions & Activation

Define two audiences in Tealium CDP to represent the groups:

• A/B Test – Control → Criteria: AB Test Group equals “Control”
• A/B Test – Test → Criteria: AB Test Group equals “Test”

Use these audiences to drive different experience paths or tactics. For example:

• Pass the value of AB Test Group to personalization engines, analytics tracking, media platforms, or activations via connectors or tags (tags via mapping and Data Layer Enrichment - https://docs.tealium.com/server-side/attributes/data-layer-enrichment/about/).
• Ensure your activation mechanism references the same attribute to deliver the correct variant to each visitor.
• Because Tealium provides a stable visitor ID and assignment logic, we can maintain the same variant delivery for the same visitor across channels/sessions. 

Step 5: Implementation Considerations & Best Practices

• Once you launch a variant test, avoid changing the enrichment logic (distribution or source test name attribute) mid-test — doing so may re-assign visitors or break consistency.
• Clearly document the test name (AB Test Name) attribute and timeframe so subsequent measurements align with the correct test version.
• If you’re using multi-variant or rolling tests, consider adding another attribute or combining test name + group attribute using a Set of Strings or Tally attribute for clarity.
• Maintain clean separation between test and control experiences in activation platforms to ensure there’s no cross-pollution (e.g., a “Control” visitor accidentally receiving the “Test” experience).
• Use the Trace tool and Visitor Profiler Sampler report within AudienceStream to verify that AB Test Group is correctly set and being passed to downstream systems (via connectors).
• After test completion, archive the logic and ensure the attribute value remains in the profile for analysis historically (do not reset immediately unless you’re launching a new test).

Summary

By using the Split String enrichment in Tealium CDP, you can assign visitors into randomized and stable test/control groups.

This approach helps you maintain group assignment across sessions and devices, feed the group values into activation channels, and measure the impact of test variants end-to-end.

Further reading: 

• https://docs.tealium.com/server-side/attributes/manage-enrichments/usage-examples/#split-string-ab-testing--split-test-group 
• https://support.tealiumiq.com/en/support/solutions/articles/36000363487-enrichment-example-split-string 

The post A/B Testing Using the Split String Enrichment in Tealium CDP appeared first on Tealium.

This is where data architecture becomes the foundation of AI success. In an era where milliseconds matter and personalization is table stakes, the ability to capture, label, and contextualize data in real-time at the point of creation isn't just an advantage—it's essential. 

Most enterprises still apply context after the fact, by which time latency and inconsistency have crept in. Tealium’s architecture embeds context as events occur, making it an inherent property of the data. In this guide, we’ll unpack how that architecture works across three data scopes and why embedding context upstream changes everything for AI.

The Context Crisis in Modern AI

Enterprises face a fundamental challenge: data without context is just noise. 

When customer interactions flow through dozens of touchpoints across web, mobile, IoT devices, and beyond, maintaining consistent context becomes exponentially complex. A page view isn't just a page view—it's part of a session, which is part of a journey, which is part of a lifetime relationship. Strip away these layers, and AI models are left making decisions based on isolated fragments rather than meaningful patterns.

Traditional data collection approaches attempt to add context after the fact, stitching disparate data points in batch processes that introduce latency, inconsistency, and gaps. By the time context is applied, the moment for real-time action has passed. The result is AI that operates on stale, poorly contextualized data, unable to respond to the dynamic reality of customer behavior.

A Modern Approach: Automated Context at the Point of Creation

Modern architecture solves this challenge through a fundamental innovation: automated context labeling across three distinct data scopes, applied in real-time at the moment of data creation. 

Rather than collecting raw data and attempting to contextualize it later, a modern system intelligently categorizes every data point into one of three scopes—Event, Visit, and Visitor—with sub-200ms latency. This approach ensures that context is never an afterthought but an inherent property of the data itself.

Event Scope: Capturing the Atomic Moment

At the most granular level, the Event Scope captures individual user interactions as discrete, time-stamped actions. Every click, page view, mouse over, swipe, form submission, or custom event is labeled and processed in real-time, providing AI models with the high-velocity data required for instantaneous decision-making.

This scope enables low-latency adaptive modeling where AI systems can respond to user behavior as it unfolds. Whether detecting anomalies that signal fraudulent activity, triggering event-driven automation, generating real-time sentiment and propensity or personalizing content on the fly, Event Scope data provides the real-time pulse of customer interaction. 

The critical advantage is that each event arrives pre-contextualized with metadata that describes not just what happened, but when, where, and under what circumstances.

Visit Scope: Understanding the Session Journey

While events capture individual moments, Visit Scope aggregates all actions within a single session to provide contextual understanding of user intent and behavior. This session-based view is essential for AI applications that need to understand patterns within a continuous interaction.

Visit Scope enables sophisticated session-based journey analysis, allowing AI models to score engagement levels, predict exit likelihood, and optimize experiences dynamically throughout the session. By automatically consolidating event-level data into session context, Tealium eliminates the complexity of manual session reconstruction. AI models receive structured session-level insights that reveal the narrative of each visit—the path taken, the engagement demonstrated, the obstacles encountered. Think of a session that can be summarized by an agent and then have that payload sent to the next channel of engagement. 

Visitor Scope: Building Historical Intelligence

The most powerful AI applications require understanding customers across time. Visitor Scope tracks user behavior across multiple sessions, creating a persistent, historical view that enables predictive modeling and long-term personalization.

This scope is essential for AI-driven applications like lifetime value prediction, churn forecasting, and behavioral segmentation. By automatically maintaining visitor-level context across sessions, devices, and channels, this modern approach provides AI models with the enriched data necessary to identify trends, predict future behavior, and personalize experiences based on cumulative knowledge rather than isolated interactions.

Multi-Scope Integration: The Compound Effect of Layered Context

The true power of this approach emerges when these three scopes work in concert. AI models that can simultaneously access event-level granularity, visit-level session context, and visitor-level historical patterns achieve a depth of understanding impossible with single-scope data.

Consider the compound effect on multi-layered attribution modeling: 

• event-level data provides immediate tracking of conversion touchpoints 
• visit-level data adds session context to understand the journey leading to conversion
• visitor-level data reveals the long-term nurturing process across multiple sessions 

This layered approach transforms attribution from a simple last-click analysis to a sophisticated understanding of the entire customer relationship.

Similarly, fraud prevention and anomaly detection benefit enormously from multi-scope context. Real-time event data might flag a suspicious transaction, but correlating that event against visit-level session patterns and visitor-level historical behavior allows AI to distinguish between genuine anomalies and expected variations. The result is dramatically improved precision, reducing false positives while catching genuine threats.

Trust at Real-Time Scale

Trust in AI comes from consistency, reliability, and standardization. Automated labeling ensures that context is applied uniformly across every touchpoint, every channel, and every moment of the customer journey. This standardization eliminates the variability that plagues manual tagging, where inconsistent implementation creates data quality issues.

But trust must be earned. In today's landscape, that means respecting customer privacy, consent and maintaining compliance with regional regulations like GDPR, CCPA, and emerging privacy frameworks worldwide. Trust in AI systems isn't just about technical accuracy—it's about demonstrating that customer data is collected, processed, and utilized with proper consent and in accordance with applicable laws.

Tealium's architecture recognizes that context and compliance are inseparable. The same real-time labeling system that categorizes data across event, visit, and visitor scopes also tracks consent preferences and privacy signals at the point of data creation. Every data point carries not only contextual metadata but also consent status, ensuring that AI models only operate on data where proper authorization exists. When a customer withdraws consent or exercises their privacy rights, those preferences propagate across all three scopes immediately, maintaining compliance while preserving the integrity of the customer relationship.

The same design that enforces governance also delivers speed. With sub-200ms latency, Teealium’s real-time architecture ensures that machine learning models designed for real-time personalization, dynamic pricing, fraud detection, or adaptive content delivery receive immediate access to properly contextualized and enriched data. There’s no batch processing delay, no reprocessing step - just data that’s structured, enriched, and immediately usable acros downstream systems.

When every event, visit, and visitor data point follows the same structural model and carries the same contextual metadata, AI models can operate with confidence. Training becomes more effective, predictions become more reliable, and business users can trust that insights derived from AI reflect genuine patterns rather than artifacts of inconsistent data collection.

Building AI You Can Trust

Without proper contextualization, even the most sophisticated algorithms produce unreliable results that erode trust and undermine business value. But context alone isn't enough. That context must be standardized, automated, and delivered in real-time to meet the demands of modern AI.

Tealium's three-scope data architecture—automatically labeling and contextualizing data at the event, visit, and visitor levels—eliminates the gap between data collection and AI readiness. There's no separate contextualization step, no batch processing lag, no manual tagging inconsistencies.

By ensuring that context is inherent in the data itself rather than applied after the fact, Tealium enables AI that is more accurate, more responsive, and more aligned with customer behavior. As businesses increasingly rely on AI for personalization, optimization, and decision-making, the question isn't whether context matters—it's whether your data architecture can deliver it consistently, comprehensively, and in real-time. 

The post In the Age of AI, Context is King…But Trust Rules the Land appeared first on Tealium.

This article outlines how to use Tallies and Timelines in Tealium CDP to track attribution-related events and interactions over specific defined periods of time.

This method enables brands to classify, categorize, and analyze attribution across multiple visits. We’ll use this method to capture and analyze campaign source types, traffic channels, or UTM parameters—enabling more accurate attribution modeling, remarketing logic, and performance analysis.

Key Objectives:

• Track which marketing sources or channels brought users to the site.
• Identify the most frequent sources contributing to engagement.
• Maintain a rolling history of attribution events over a 180-day window.
• Use this data for campaign performance analysis, remarketing, and personalization.

Step 1: Creating a Visit-Scoped Tally for Attribution Events

Start by capturing attribution-related values during each session.

1. Define a Visit-Scoped Tally Attribute named Attribution Source Tally.
2. Create Enrichments to populate the Tally using Rules associated with:
   1. Values from UTM parameters (e.g., utm_source, utm_medium, keyword, or referrer domain) present in the data layer.
   2. Values from email or paid media attribution campaigns (querystring parameters, fbclid or gclid parameters, or campaign-specific attribution values in the data layer)
   3. Values from specific attribution events in the data layer (for example, entering a coupon code at checkout associated with a specific campaign would trigger an attribution event to be enriched into the the Tally)
3. What This Does: Tracks specific attribution sources associated with the current visit.

Step 2: Storing Tally Visit Data in a Timeline

To extend tracking of the tally beyond a single session, store visit-scoped data in a Timeline Attribute.

1. Create a Visitor-Scoped Timeline Attribute named Attribution Events Timeline. 
2. When creating the Timeline, set an expiration retention window of 180 days.
3. At the end of each session, populate the Timeline by setting an Update enrichment that includes the visit-scoped Tally.
4. What This Does: Preserves historical attribution trends, such as multiple sessions attributed to email or paid search over a rolling time period defined by the retention window.

Step 3: Creating a Visitor-Scoped Tally for Rolling Long-Term Attribution Measurement

To maintain an up-to-date count of attribution events over time, we enrich a Visitor-Scoped Tally Attribute with data from the timeline.

1. Define a Visitor-Scoped Tally Attribute named180-Day Attribution Source Tally.
2. Set the enrichment rule to sum the tally of values from the Attribution Events Timeline.
3. What This Does: Rather than endlessly increasing, this tally keeps a rolling count of each attribution source, maintaining an accurate attribution window covering only the last 180 days of visitor activity. 

Step 4: Creating a Set of Strings for Attribution Sources

To power audience segmentation or suppression logic based on source exposure:

1. Create a Visitor-Scoped Set of Strings Attribute named Attribution Sources Seen.
2. Populate it by creating a Set to Tally Items Above Target Value enrichment to extract the unique sources from the 180-Day Attribution Source Tally.
3. What This Does: Maintains a deduplicated list of all attribution channels a visitor has interacted with in the past 180 days.

Use Cases

Attribution Analysis & Campaign Optimization

• Evaluate which sources drive the most engagement over time.
• Personalize site experiences based on the most frequent referring channel.
• Build audiences based on dominant source exposure (e.g., "frequent organic users").

Audience Suppression & Remarketing

• Suppress acquisition campaigns to users who’ve already engaged through bottom-funnel channels.
• Dynamically adjust ad messaging or bidding based on top historical sources.
• Re-engage visitors based on a drop-off in source frequency.

Beyond UTM Parameters

• Apply this method to track referrer domains, campaign IDs, or internal promotional banners.
• Segment users who have interacted with specific content sources (e.g., blog newsletter vs. product landing page).
• Align internal performance metrics with long-term channel exposure patterns.

Summary

Using Tallies, Timelines, and Sets of Strings, Tealium CDP enables brands to capture, store, and analyze long-term visitor engagement. These insights can drive personalization, audience segmentation, and marketing optimization for better customer experiences.

The post Tracking Attribution Engagement with Tallies and Timeline Attributes in Tealium CDP appeared first on Tealium.

For merchants, this shift raises an important question:

How do we continue collecting accurate, trustworthy, and richly detailed data across the entire customer journey when the old methods no longer exist?

The Tealium Shopify App was built from the ground up to solve exactly that challenge.
Designed for storefront performance, built for global commerce, and engineered to match Shopify’s evolving architecture, the app creates a seamless bridge between Shopify and Tealium’s powerful data platform.

Whether you’re a fast-moving DTC brand, a multi-market retailer, or an enterprise-scale brand with advanced governance needs, the Tealium Shopify App provides a future-proof foundation for high-quality ecommerce data collection.

Who Is This App For?

The Tealium Shopify App is designed for the modern commerce ecosystem—brands that prioritize accuracy, performance, and seamless scaling.

It is especially valuable for:

• Direct-to-consumer brands

• Retailers expanding globally using Shopify Markets

• Multi-store or multi-location merchants using Shopify POS

• Subscription, membership, and loyalty-driven businesses

• Enterprise teams managing strict privacy and governance models

Whether you sell into one region or dozens, the app adapts to your configuration and data strategy.

Shopify Markets Support: Built for Global Commerce

As more brands expand internationally, Shopify Markets has become a central pillar of multi-region commerce. It allows merchants to manage one central store while tailoring pricing, currency, domains, language, duties, and localisation for each market.

The Tealium Shopify App is designed to work seamlessly in this ecosystem.

Because the app standardises the Unified Data Object (UDO), event tracking, and enrichment logic across all regions, merchants gain:

• Consistent tracking across all Market storefronts

• Unified customer data regardless of region or domain

• Accurate attribution even when shoppers switch between markets

• Server-side events that remain stable across currencies and localised experiences

And for brands operating physical stores alongside global ecommerce, the app also complements Shopify POS’s multi-store capabilities, allowing in-person and online data to funnel into one Tealium data foundation.

Whether your business sells in one language or twenty, one currency or fifty, Tealium ensures your tracking remains unified, enriched, and globally consistent.

A Refreshed, Reliable UDO (Universal Data Object)

A high-quality data layer is the backbone of any reliable analytics setup. Inside the Tealium Shopify App, we’ve completely refreshed the Standard UDO and embedded it directly into the storefront.

This gives you:

• Clean, predictable page-level data

• A consistent structure across themes and storefronts

• Immediate compatibility with Tealium’s tags, extensions, and server-side workflows

No more custom Liquid templates. No more fragile snippets. The UDO is fully standardised and automatically maintained.

Comprehensive Event Tracking Right Out of the Box

E-commerce measurement depends on capturing the right moments. The Tealium Shopify App tracks a broad range of events automatically, including:

• cart_view

• cart_add

• cart_remove

• search

• checkout_started

• purchase (Shopify native)

• shipping_info_added

• payment_info_added

These events require no manual configuration and work instantly across your storefront.

Store-specific events such as newsletter sign-ups or discount applications can be added depending on each merchant’s theme or third-party tools.

Solving Shopify Checkout Deprecation

For years, merchants relied on checkout.liquid or Additional Scripts to inject tracking tags.
But Shopify has begun removing these pathways, forcing merchants to transition to:

• Customer Events

• Web Pixels

• Server-side signals

• Shopify’s Privacy API

The Tealium Shopify App includes a dedicated Tealium Checkout Pixel designed specifically for Shopify’s new checkout architecture.

This pixel:

• Captures checkout behaviour without relying on deprecated scripts

• Works within Shopify’s sandboxed environment

• Ensures attribution continuity across payment and checkout steps

• Mirrors your Tealium settings from onboarding for full alignment

• Provides consistency across Markets storefronts and POS retail channels

It’s the clean, forward-compatible, Shopify-approved method for tracking checkout now and in the future.

Three Tracking Modes for Complete Flexibility

Every merchant’s data strategy looks different.
To support that diversity, the app offers three distinct modes:

1. Client-Side Only

Loads utag.js and uses Shopify Web Pixels for checkout events.

2. Hybrid (Both Client & Server)

Combines behavioural data from the frontend with authoritative server-side events.
Perfect for teams using both Tealium iQ and EventStream.

3. Server-Side Only

• No frontend script

• Minimal JS overhead

• All events sent via the Tealium Collect endpoint

Great for privacy-first implementations and performance-critical storefronts.

Webhook-Based Server-Side Tracking

The app supports Shopify Webhooks fully, capturing:

With Visitor ID (stitching supported)

• Purchase

• Refund

• Customer Updated

Anonymous

• cart_add

• cart_remove

• checkout_started

This hybrid model ensures reliable tracking even when cookies or scripts are blocked.

Rich Purchase Event Enrichment

When purchase events fire, the app automatically enriches them using Shopify’s GraphQL API, adding:

• Customer lifetime value

• Total order count

• Membership in Shopify customer segments

• Consent status for email and SMS

• Tags and data sale opt-out preferences

• Recent abandoned checkout information

This transforms purchase data from a simple transaction into a powerful customer insight asset.

Enhanced Product & Collection Page Tracking

The app captures detailed product and merchandising data across the storefront:

Product Detail Pages

• Product ID, SKU, price, variants

• Inventory and availability

• Name and metadata

• Logged-in customer identifiers

• Regional market context

Collection Pages

• Product impression data

• Support for recommendation logic and retail media analytics

Perfect for brands focused on merchandising optimisation or audience building.

Server Events Management Interface

Within the app settings, merchants can:

• Enable or disable webhook events

• Register Shopify Webhooks automatically

• Configure event routing into Tealium EventStream

No engineering required—just select, save, and the app handles the rest.

Split Cookie Support

For organisations using utag.js 4.50+, the app supports split cookie mode:

• Detects Tealium script version automatically

• Allows merchants to select which values belong in the main utag_main cookie

• Writes all other values as individual cookies for transparency

Perfect for teams with strict privacy and compliance guidelines.

A Simple, Guided Installation

The installation process is intentionally streamlined:

Step 1: Enter your Tealium Account/Profile/Environment details

Step 2: Enable the Theme App Extension

Step 3: Install the Tealium Checkout Pixel

The app carries your configuration through each step automatically.

Developer-Friendly Debugging, Even in Shopify’s Sandbox

Shopify Custom Pixels execute inside a restrictive iframe, making conventional debugging tools ineffective.
The Tealium app solves this with a built-in Debug Mode that exposes:

• utag.js logs

• Pixel event logs

• Theme App Extension activity

• Optional environment overrides

Just toggle Debug Mode on, reload the site, and the console becomes fully transparent.

Built for the Future of Shopify

As Shopify continues evolving its platform—moving toward server-side signals, unified privacy, smarter global commerce, and cleaner tracking models—the Tealium Shopify App ensures merchants have a durable, flexible, and enterprise-ready foundation.

For brands preparing for international expansion, dealing with checkout complexity, or modernising legacy analytics setups, Tealium offers a path that is stable, compliant, and deeply aligned with Shopify’s future direction.

Learn More

The post Introducing the Tealium Shopify App: A Modern, Future-Proof Approach to Ecommerce Data Collection appeared first on Tealium.

In my time leading AI solutions for Samsung’s eCommerce business, I saw how impactful well-integrated machine learning can be when applied to customer data at scale. We deployed both real-time and batch recommendation systems across multiple funnels, personalizing experiences for over 200+ million users. From building predictive affinity models to leading platform-level AI innovations, the challenge was always the same: connecting rich, timely data to intelligent real-time decision-making systems in production.

Now, working closely with Tealium customers, I see the same challenge and familiar patterns emerging across industries. This post is a practical breakdown of the major enterprise AI use cases I’ve encountered, focused on what developers need to know to build scalable, real-time, and personalized AI workflows.

1. Product Recommendations and Personalization Engines

Teams It Benefits: Marketing, eCommerce

Technical Focus: Real-time data pipelines → ML inference endpoints → activation via personalization channels

Enterprises are building recommendation engines that personalize offers, products, or content using live behavioral data. These often combine in-house trained ML or tuned LLM models (hosted on platforms like AWS SageMaker, Google Cloud Vertex AI or Snowflake) with real-time scoring pipelines triggered by Tealium.

Example pattern: A global retailer collects behavior data through Tealium iQ and AudienceStream, then streams enriched profiles into a cloud ML service for inference. The model outputs product rankings, which are sent to an email for post-visit personalization or on-site personalization engine in real-time. In one case, AWS Lambda functions trigger SageMaker to personalize a relevant product for each user based on in-session propensity score or product affinity score.

Developer takeaway: This use case highlights the importance of low-latency, event-driven architectures. You’ll be managing ML/AI model development, event streams, API integrations, and the logic for triggering model scoring in near-real time.

2. Predictive Scoring and Next Best Action

Teams It Benefits: Marketing, Sales, Customer Retention

Technical Focus: Event data streaming → scoring models → decisioning systems (e.g. Pega, custom engines)

Another dominant use case is real-time propensity scoring and "Next Best Action" (NBA) decisioning. Here, customer behavior and profile data is sent to a model that predicts the best action to take: send a promotion, recommend a call, or offer a service upgrade.

Example pattern: Customers use Tealium to collect session data, stream it into Snowflake, and run models to determine upgrade propensities. From there, they can trigger targeted offers through various channels such as on-site banners or email. One company shrank scoring latency from two days to under one minute using this architecture.

Another customer in financial services feeds AudienceStream data into Pega’s NBA engine, which recommends personalized outreach (e.g. send a quote reminder) based on user behavior and AI model outputs.

Developer takeaway: Using Tealium’s intelligent data platform to feed customer profile information in real time to a propensity model can help improve customer targeting. By handling the data wrangling for developers, Tealium is able to save development effort when connecting streaming data pipelines to scoring endpoints and business rules engines.

3. Chatbots and Conversational AI Enrichment

Team It Benefits: Customer Support, Sales Enablement
Technical Focus: LLM orchestration → real-time data enrichment → API-based chatbot platforms

Chatbots aren’t new, but the new wave of AI-powered assistants—often backed by large language models (LLMs)—are far more powerful. The real breakthrough for developers is context enrichment: using Tealium data to personalize chatbot (or voice AI) behavior.

Example pattern: A major bank uses Tealium to stream consented user traits and behavior into their LLM-driven chatbot. The bot adapts its tone and responses based on each user profile (e.g., casual tone for younger users) and references recent activity (e.g., “I see you were looking at mortgage calculators”). Other companies feed session data into call center AI agents to generate call summaries, suggest responses, or route calls intelligently.

Developer takeaway: You’ll be integrating APIs between CDPs, LLMs, and messaging platforms. Consider allowing the chatbot / agent to access Tealium's APIs via MCP to enable open and easy integration of context.  Pay attention to latency to ensure your chatbot or agent can respond ‘in the moment’ and consider the issues of data minimization, since sometimes there can be such things as too much context.

4. Fraud Detection and Risk Signals

Teams It Benefits: Operations, Security, Financial Services

Technical Focus: High-velocity data ingestion → ML model scoring → alerting or workflow triggers

In industries like banking and eCommerce, AI is used to flag suspicious behaviors—impossible travel logins, bot traffic, or anomalous transactions.

Example pattern: A financial institution uses Tealium AudienceStream to stream behavioral events (e.g., device, location, frequency) into a fraud detection model. The model is scored on the fly and, if risk is high, signals are passed to the security stack for flagging or escalation.

In another example, a telecom scores incoming orders with a predictive model to assess rejection likelihood due to fraud.

Developer takeaway: These systems are performance-sensitive and require high-throughput, low-latency pipelines. Expect to work closely with ML teams on model interfaces and with security teams on alert routing.

5. Sentiment Analysis and Voice of Customer

Teams It Benefits: Customer Experience, Product, Marketing
Technical Focus: Text ingestion → NLP/LLM services → dashboards or segmentation

Companies are increasingly analyzing unstructured feedback—support transcripts, product reviews, surveys—to uncover customer sentiment.

Example pattern: A mortgage company feeds customer call transcripts into a large language model for sentiment tagging and topic extraction. These signals feed back into AudienceStream to power re-engagement campaigns (e.g., “follow up with frustrated users”).

Another example involves summarizing product reviews using a custom model deployed in Databricks, then surfacing highlights in customer-facing pages (“Most users loved the battery life”).

Developer takeaway: You'll often be building pipelines from raw text sources into NLP or LLM services, then integrating structured outputs back into the customer data layer. Watch for privacy concerns (e.g., PII in call logs), and ensure feedback loops are tight.

6. Generative AI for Content and Search

Teams It Benefits: Marketing, Digital Experience, Commerce

Technical Focus: Prompt engineering → context injection → content generation or search result ranking

Some enterprises are testing generative AI to enhance internal tools (like search) or customer-facing outputs (like email campaigns).

Example pattern: A major airline built an AI destination search using a generative model. Tealium’s Moments API provides real-time user data (past trips, preferences) that is injected into the AI’s prompt, allowing for more tailored travel suggestions. Similarly, a car marketplace combines lead classification models with LLMs to generate email follow-ups.

Developer takeaway: These use cases often involve combining real-time user context with carefully structured prompts to control the behavior of LLMs. Expect to work on prompt templating, latency reduction, and fallback logic.

Final Thoughts for Developers

If you’re a developer working with Tealium or exploring AI use cases in your stack, these patterns show where the industry is heading:

• AI in production means real-time orchestration: the days of batch-only pipelines are fading fast.
• Tealium is often used as the real-time context layer, feeding live behavior and profiles into models, decisioning engines, and downstream apps.
• Success depends on connectivity: clean APIs, flexible data models, and strong observability into where and how AI insights are used.

Whether you're building a proof-of-concept chatbot or optimizing an enterprise-scale recommendation engine, the blueprint is already out there. You don’t have to start from scratch—just build on what’s working.

The post Deploying Six Real-World AI Use Cases in the Enterprise with Tealium appeared first on Tealium.