Quick-Start Guide: Make Your Website Agent-Ready with Tealium iQ

Before you configure anything, verify that the brand’s utag_data object includes product-level variables on product pages. Open a product page with the Tealium Tools browser extension and check for these variables:

If the data layer doesn’t have these: Work with the customer to add them. Most e-commerce platforms (Shopify, Magento, Salesforce Commerce) already populate these — they may just need to be mapped in TiQ.

If you’re missing ratings or review data: That’s fine. The extension handles missing values gracefully. Add what you have; more is better.

In Tealium iQ: Extensions → Add Extension → JavaScript Code

• Name: Agent-Ready Structured Data (JSON-LD)
• Scope: All Tags  |  Execution: After Load Rules
• Condition: page_type equals product

Paste the following code:

// Agent-Ready Structured Data Injection
// Injects schema.org JSON-LD for AI agent consumption
// Only runs on product pages (gated by extension condition)

(function() {
  if (window.__tealium_agent_schema_injected) return;
  window.__tealium_agent_schema_injected = true;

  var product = {
    "@context": "https://schema.org",
    "@type": "Product",
    "name": b['product_name'] || '',
    "sku": b['product_id'] || b['product_sku'] || '',
    "description": b['product_description'] || '',
    "brand": {
      "@type": "Brand",
      "name": b['product_brand'] || ''
    },
    "offers": {
      "@type": "Offer",
      "price": b['product_price'] || '',
      "priceCurrency": b['product_currency'] || 'USD',
      "availability": (b['product_availability'] || '').toLowerCase() === 'in stock'
        ? 'https://schema.org/InStock'
        : 'https://schema.org/OutOfStock',
      "url": window.location.href
    }
  };

  if (b['product_category']) product.category = b['product_category'];
  if (b['product_image_url']) product.image = b['product_image_url'];

  if (b['product_rating'] && b['product_review_count']) {
    product.aggregateRating = {
      "@type": "AggregateRating",
      "ratingValue": b['product_rating'],
      "reviewCount": b['product_review_count'],
      "bestRating": "5"
    };
  }

  if (b['product_return_days']) {
    product.hasMerchantReturnPolicy = {
      "@type": "MerchantReturnPolicy",
      "merchantReturnDays": b['product_return_days'],
      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow"
    };
  }

  var script = document.createElement('script');
  script.type = 'application/ld+json';
  script.text = JSON.stringify(product);
  document.head.appendChild(script);
})();

Click Apply, then Save the profile.

Name: Agent Meta Tags  |  Same scope and condition as Step 2.

// Agent-Friendly Meta Tags

(function() {
  if (window.__tealium_agent_meta_injected) return;
  window.__tealium_agent_meta_injected = true;

  var metas = [
    { property: 'product:price:amount',    content: b['product_price'] },
    { property: 'product:price:currency',  content: b['product_currency'] || 'USD' },
    { property: 'product:availability',    content: b['product_availability'] || '' },
    { property: 'product:brand',           content: b['product_brand'] || '' },
    { property: 'product:category',        content: b['product_category'] || '' }
  ];

  if (b['loyalty_message']) {
    metas.push({ property: 'product:loyalty_offer', content: b['loyalty_message'] });
  }
  if (b['product_repeat_purchase_rate']) {
    metas.push({ property: 'product:repeat_purchase_rate', content: b['product_repeat_purchase_rate'] });
  }

  metas.forEach(function(m) {
    if (m.content) {
      var tag = document.createElement('meta');
      tag.setAttribute('property', m.property);
      tag.setAttribute('content', m.content);
      document.head.appendChild(tag);
    }
  });
})();

If the brand has Moments API or Data Layer Enrichment enabled, you can inject CDP profile data into the structured markup — the agent sees personalized product data, not just generic page data. Add this after the product object in the JSON-LD extension:

if (b['loyalty_points_balance']) {
  product.offers.priceSpecification = {
    "@type": "PriceSpecification",
    "price": b['product_price'],
    "priceCurrency": b['product_currency'] || 'USD'
  };
  product.additionalProperty = product.additionalProperty || [];
  product.additionalProperty.push({
    "@type": "PropertyValue",
    "name": "loyaltyDiscount",
    "value": b['loyalty_points_balance'] + " points available"
  });
}

if (b['product_affinity_score']) {
  product.additionalProperty = product.additionalProperty || [];
  product.additionalProperty.push({
    "@type": "PropertyValue",
    "name": "recommendationStrength",
    "value": b['product_affinity_score']
  });
}

What this does: When an agent retrieves this page for a known visitor, the structured data includes personalized loyalty pricing and affinity scores — the data that tips an agent’s decision from “cheapest option” to “best option for this customer.”

• Publish to Dev environment.
• Open a product page → DevTools → Elements → search for application/ld+json. Verify the JSON-LD is present and populated correctly.
• Google’s Rich Results Test: search.google.com/test/rich-results — paste the page URL and confirm valid structured data.
• Test with an agent: Open ChatGPT, ask it to find the product, and see if the structured data influences the response.
• Publish to QA then Prod when validated.

AudienceStream rule (configure server-side):

• referrer contains chatgpt.com → set acquisition_channel = “ai_agent_chatgpt”
• referrer contains gemini.google.com → set acquisition_channel = “ai_agent_gemini”
• referrer contains perplexity.ai → set acquisition_channel = “ai_agent_perplexity”

Build an audience: “AI Agent Referred Visitors” — then compare conversion rates, AOV, and LTV for agent-referred traffic vs. organic. That number is probably already 5–10% of your traffic and growing. Nobody’s measuring it yet.

“Why should I care about structured data for agents?”

AI agents are already shopping for your customers. When ChatGPT searches for running shoes, it reads your product pages the same way Google does. The brands with clean, machine-readable product data — price, ratings, availability, return policy — win the recommendation. Your competitors are starting to optimize for this. TiQ lets you do it today without touching your site code.

“How is this different from SEO?”

SEO structured data helps Google rank your page. Agent structured data helps AI recommend your product. The schema.org format is the same, but the intent is different. Google shows a link — an agent makes a purchase decision. The structured data needs to include things agents care about that Google doesn’t: return rates, repeat purchase rates, loyalty pricing, satisfaction scores. TiQ can inject all of this from your data layer.

“Can we personalize the structured data per visitor?”

Yes — if you have Moments API or Data Layer Enrichment, the TiQ extension can inject visitor-specific data into the markup. An agent retrieving the page for a known customer can see their loyalty balance, personalized pricing, and product affinity score right in the structured data. That’s the data that makes an agent pick your brand over the cheapest alternative.

“How do we know it’s working?”

We configure AudienceStream to tag visitors referred by AI agents — chatgpt.com, gemini.google.com, perplexity.ai — as a distinct channel. You’ll see the volume, conversion rate, and AOV for agent-referred traffic. That number is probably already 5–10% of your traffic and growing. Nobody’s measuring it yet.

Next Steps After Setup

Once structured data is live and agent referral tracking is configured:

• Register the brand’s MCP server as a ChatGPT GPT Action — so agents get personalized CDP data, not just page-level structured data.
• Monitor MCP server logs for agent interaction patterns.
• Propose the MCP event emission pipeline — agent interaction events flowing back into AudienceStream.

This TiQ configuration is Step 1 of the ladder. It’s free, it’s fast, and it gives the brand immediate visibility into agent-driven traffic while setting up the infrastructure for deeper agent integration.