Amazon Advertising Cross-Domain Tracking | OpsBlu Docs

Amazon Advertising Cross-Domain Tracking

Implementation strategies for maintaining Amazon Ads attribution across multiple domains and subdomains.

Cross-Domain Tracking Overview

Cross-domain tracking ensures Amazon Ads attribution parameters persist when users navigate between different domains or subdomains in your web ecosystem. This is critical for accurate conversion attribution when checkout flows, landing pages, or content sites operate on separate domains.

Common Cross-Domain Scenarios

  • Marketing site to e-commerce store: example.com → shop.example.com
  • Third-party checkout: mysite.com → secure-checkout-provider.com → mysite.com
  • Multi-brand properties: brand-a.com → brand-b.com (same parent company)
  • Regional domains: example.com → example.co.uk
  • Landing page platforms: mysite.com → lp.marketingplatform.com

Attribution Parameter Persistence

Amazon Attribution Tag Parameters

When using Amazon Attribution, these parameters must persist across domains:

  • tag: Amazon Attribution tag identifier
  • amzn_click_id: Amazon click identifier for conversion attribution
  • Additional UTM parameters: utm_source, utm_medium, utm_campaign, utm_content, utm_term

URL Parameter Preservation

Ensure attribution parameters append to all cross-domain links:

// Function to append Amazon parameters to cross-domain links
function decorateCrossDomainLinks() {
  var amazonParams = getAmazonParameters();
  var targetDomains = ['shop.example.com', 'checkout.example.com'];

  if (!amazonParams) return;

  document.querySelectorAll('a').forEach(function(link) {
    var linkDomain = new URL(link.href).hostname;

    if (targetDomains.includes(linkDomain)) {
      link.href = appendParameters(link.href, amazonParams);
    }
  });
}

// Extract Amazon parameters from current URL
function getAmazonParameters() {
  var params = new URLSearchParams(window.location.search);
  var amazonParams = {};

  ['tag', 'amzn_click_id', 'utm_source', 'utm_medium', 'utm_campaign'].forEach(function(param) {
    var value = params.get(param);
    if (value) {
      amazonParams[param] = value;
    }
  });

  return Object.keys(amazonParams).length > 0 ? amazonParams : null;
}

// Append parameters to URL
function appendParameters(url, params) {
  var urlObj = new URL(url);

  Object.keys(params).forEach(function(key) {
    urlObj.searchParams.set(key, params[key]);
  });

  return urlObj.toString();
}

// Run on page load
window.addEventListener('load', decorateCrossDomainLinks);

Implement automatic link decoration for dynamic content:

// Monitor DOM for new links and decorate them
var observer = new MutationObserver(function(mutations) {
  decorateCrossDomainLinks();
});

observer.observe(document.body, {
  childList: true,
  subtree: true
});

Store Amazon attribution data in first-party cookies for cross-subdomain persistence:

// Store Amazon parameters in cookie
function storeAmazonParameters() {
  var params = getAmazonParameters();

  if (params) {
    // Store for 30 days across all subdomains
    document.cookie = 'amazon_attribution=' + JSON.stringify(params) +
      '; domain=.example.com; path=/; max-age=2592000; SameSite=Lax; Secure';
  }
}

// Retrieve stored parameters
function getStoredAmazonParameters() {
  var match = document.cookie.match(/amazon_attribution=([^;]+)/);

  if (match) {
    try {
      return JSON.parse(decodeURIComponent(match[1]));
    } catch (e) {
      console.error('Failed to parse Amazon attribution cookie:', e);
      return null;
    }
  }

  return null;
}

// On page load, store parameters or retrieve from cookie
window.addEventListener('load', function() {
  var urlParams = getAmazonParameters();

  if (urlParams) {
    storeAmazonParameters();
  } else {
    // If no URL parameters, check for stored attribution
    var storedParams = getStoredAmazonParameters();
    if (storedParams) {
      decorateCrossDomainLinks();
    }
  }
});

Configure cookie domain for optimal cross-subdomain tracking:

function getCookieDomain() {
  var hostname = window.location.hostname;

  // For subdomains, use parent domain
  if (hostname.match(/^[^.]+\.[^.]+\.[^.]+$/)) {
    // Extract parent domain (e.g., shop.example.com → .example.com)
    return '.' + hostname.split('.').slice(-2).join('.');
  }

  // For root domains, use current domain
  return hostname;
}

function setAmazonCookie(data) {
  var domain = getCookieDomain();

  document.cookie = 'amazon_attribution=' + JSON.stringify(data) +
    '; domain=' + domain +
    '; path=/; max-age=2592000; SameSite=Lax; Secure';
}

Form-Based Parameter Passing

For POST requests or redirects that don't preserve URL parameters:

// Add hidden fields to forms for parameter persistence
function addAmazonParametersToForms() {
  var params = getAmazonParameters() || getStoredAmazonParameters();

  if (!params) return;

  document.querySelectorAll('form').forEach(function(form) {
    var formDomain = new URL(form.action).hostname;
    var currentDomain = window.location.hostname;

    // Only add fields for cross-domain forms
    if (formDomain !== currentDomain) {
      Object.keys(params).forEach(function(key) {
        var input = document.createElement('input');
        input.type = 'hidden';
        input.name = key;
        input.value = params[key];
        form.appendChild(input);
      });
    }
  });
}

window.addEventListener('load', addAmazonParametersToForms);

Third-Party Redirect Handling

Redirect Chain Preservation

When users navigate through third-party redirects (e.g., payment processors):

// Before redirecting to third-party, store attribution
function handleThirdPartyRedirect(redirectUrl) {
  var params = getAmazonParameters();

  if (params) {
    // Store in cookie for retrieval after redirect
    storeAmazonParameters();

    // Also append to redirect URL if possible
    var decoratedUrl = appendParameters(redirectUrl, params);

    // Add return URL with parameters
    var returnUrl = window.location.origin + '/checkout/complete';
    returnUrl = appendParameters(returnUrl, params);

    decoratedUrl = appendParameters(decoratedUrl, {
      'return_url': returnUrl
    });

    window.location.href = decoratedUrl;
  } else {
    window.location.href = redirectUrl;
  }
}

Return URL Attribution Recovery

When user returns from third-party:

// On return from third-party, recover attribution
function recoverAttribution() {
  var urlParams = getAmazonParameters();
  var cookieParams = getStoredAmazonParameters();

  // Prefer URL parameters, fall back to cookie
  var attribution = urlParams || cookieParams;

  if (attribution) {
    // Send conversion with recovered attribution
    aw('conversion', {
      transactionId: getOrderId(),
      value: getOrderValue(),
      currency: 'USD',
      // Include attribution context
      amazonTag: attribution.tag,
      clickId: attribution.amzn_click_id
    });
  }
}

Tag Manager Implementation

Google Tag Manager Cross-Domain Configuration

Step 1: Configure Cross-Domain Tracking Variable

Create GTM variable to store target domains:

Variable Name: Cross-Domain Domains
Variable Type: Constant
Value: shop.example.com,checkout.example.com,secure.example.com

<script>
(function() {
  var targetDomains = {{Cross-Domain Domains}}.split(',');
  var amazonParams = ['tag', 'amzn_click_id', 'utm_source', 'utm_medium', 'utm_campaign'];

  // Get current Amazon parameters
  var params = {};
  amazonParams.forEach(function(param) {
    var value = {{URL - [param]}};
    if (value) params[param] = value;
  });

  if (Object.keys(params).length === 0) return;

  // Decorate links
  document.addEventListener('click', function(e) {
    var link = e.target.closest('a');
    if (!link) return;

    var linkDomain = new URL(link.href).hostname;

    if (targetDomains.some(function(d) { return linkDomain.includes(d); })) {
      Object.keys(params).forEach(function(key) {
        var url = new URL(link.href);
        url.searchParams.set(key, params[key]);
        link.href = url.toString();
      });
    }
  }, true);
})();
</script>

Trigger: All Pages

Step 3: Create URL Parameter Variables

Create GTM variables for each Amazon parameter:

  • Variable Name: URL - tag
  • Variable Type: URL
  • Component Type: Query
  • Query Key: tag

Repeat for amzn_click_id, utm_source, utm_medium, utm_campaign

Subdomain Tracking

For same-domain tracking across subdomains (www.example.com ↔ shop.example.com):

// Set cookie with parent domain
function setCrossDomainCookie(name, value, days) {
  var domain = window.location.hostname.replace(/^[^.]+\./, '.');
  var expires = new Date(Date.now() + days * 864e5).toUTCString();

  document.cookie = name + '=' + encodeURIComponent(value) +
    '; expires=' + expires +
    '; domain=' + domain +
    '; path=/; SameSite=Lax; Secure';
}

// Store Amazon attribution across subdomains
setCrossDomainCookie('amazon_attribution', JSON.stringify(params), 30);

Session Storage Synchronization

For modern browsers, synchronize attribution via localStorage:

// Store attribution in localStorage
function syncAttributionStorage() {
  var params = getAmazonParameters();

  if (params) {
    localStorage.setItem('amazon_attribution', JSON.stringify(params));
    localStorage.setItem('amazon_attribution_timestamp', Date.now());
  }
}

// Retrieve and validate stored attribution
function getStoredAttribution() {
  var attribution = localStorage.getItem('amazon_attribution');
  var timestamp = localStorage.getItem('amazon_attribution_timestamp');

  if (!attribution || !timestamp) return null;

  // Expire after 30 days
  var age = Date.now() - parseInt(timestamp);
  if (age > 30 * 24 * 60 * 60 * 1000) {
    localStorage.removeItem('amazon_attribution');
    localStorage.removeItem('amazon_attribution_timestamp');
    return null;
  }

  return JSON.parse(attribution);
}

Testing Cross-Domain Tracking

Manual Testing Procedure

  1. Setup test URL: Append Amazon attribution parameters to initial landing page

    https://example.com/?tag=test-campaign&amzn_click_id=test-click-123&utm_source=amazon

  2. Navigate to second domain: Click link to cross-domain destination (e.g., shop.example.com)

  3. Verify parameter persistence: Check that all attribution parameters persist in URL

  4. Complete conversion: Process test transaction

  5. Validate attribution: Confirm conversion appears in Amazon Attribution dashboard with correct campaign attribution

Automated Testing

Use Selenium or Cypress to validate cross-domain parameter flow:

// Cypress test
describe('Cross-Domain Attribution', function() {
  it('should preserve Amazon parameters across domains', function() {
    // Visit with attribution parameters
    cy.visit('https://example.com/?tag=test&amzn_click_id=click123');

    // Click cross-domain link
    cy.get('a[href*="shop.example.com"]').click();

    // Verify parameters persisted
    cy.url().should('include', 'tag=test');
    cy.url().should('include', 'amzn_click_id=click123');

    // Complete purchase
    cy.get('[data-testid="checkout"]').click();

    // Verify attribution in conversion pixel
    cy.window().then((win) => {
      // Check that Amazon pixel fired with attribution
      // Implementation depends on your testing framework
    });
  });
});

Browser Console Debugging

// Debug cross-domain tracking in console
console.log('Current URL Parameters:', getAmazonParameters());
console.log('Stored Cookie Attribution:', getStoredAmazonParameters());
console.log('Cross-Domain Links:', Array.from(document.querySelectorAll('a')).filter(function(link) {
  return new URL(link.href).hostname !== window.location.hostname;
}).map(function(link) {
  return { href: link.href, hasAttribution: link.href.includes('tag=') };
}));

Common Issues & Solutions

Issue: Parameters Lost on Domain Change

Symptom: Attribution parameters present on Domain A, missing on Domain B

Solution:

  1. Verify link decoration script fires before user clicks
  2. Check that target domain is included in cross-domain configuration
  3. Ensure no redirects strip parameters between domains
  4. Implement cookie-based fallback for parameter recovery

Symptom: Cookie set on www.example.com not accessible on shop.example.com

Solution:

// Use parent domain for cookie
document.cookie = 'amazon_attribution=...; domain=.example.com; ...';
// Note the leading dot in ".example.com"

Issue: Third-Party Redirect Strips Parameters

Symptom: Parameters lost when passing through payment processor

Solution:

  1. Store parameters in cookie before redirect
  2. Append parameters to return URL
  3. Recover from cookie on return if URL parameters missing
  4. Consider server-side session storage for critical flows

Issue: Form POST Loses Query Parameters

Symptom: Attribution parameters not available after form submission

Solution: Add hidden form fields with attribution values (see Form-Based Parameter Passing section)

Nach oben