Volusion Analytics Implementation | OpsBlu Docs

Volusion Analytics Implementation

Install tracking scripts, configure e-commerce data layers, and implement conversion tracking on Volusion using template editing and the global footer.

Analytics Architecture on Volusion

Volusion is a hosted e-commerce platform where templates are edited through the admin panel. Analytics scripts are injected via specific areas in the template system:

  • Global Footer Code (Design > File Editor > template_xxx.html) -- scripts placed before </body> on all pages
  • Global Header -- scripts placed in <head> via the template file
  • Article system -- Volusion's "articles" (static content pages) can contain inline HTML and JavaScript
  • Order confirmation page -- limited variable exposure for transaction tracking
  • V2 themes -- newer theme framework with different template structure than legacy themes

Volusion does not support server-side scripting in templates. All custom code is client-side HTML and JavaScript injected into template regions.

Installing Tracking Scripts

Navigate to Design > File Editor and locate your active template file (e.g., template_responsive.html). Find the </body> tag and add scripts above it:

<!-- Before </body> in template file -->
<script>
(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
})(window,document,'script','dataLayer','GTM-XXXXXX');
</script>

Built-In Google Analytics Field

Volusion provides a native integration under Marketing > SEO > Analytics:

  • Enter your Google Analytics property ID (G-XXXXXXXXXX or UA-XXXXXXXX-X)
  • Volusion automatically injects the GA snippet on all pages
  • This does not support GTM or custom event tracking

V2 Theme Script Injection

V2 themes use a component-based structure. Script injection points differ:

<!-- In V2 themes, use the Layout template -->
<!-- Design > Theme Editor > Layout > Footer section -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-XXXXXXXXXX"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());
  gtag('config', 'G-XXXXXXXXXX');
</script>

Data Layer Implementation

Volusion does not expose server-side template variables for most page types. Data layer construction relies on scraping DOM elements or using the Volusion API.

Product Page Data Layer via DOM Parsing

Since Volusion does not provide template tokens for JavaScript, parse product data from the rendered page:

<script>
document.addEventListener('DOMContentLoaded', function() {
  var productName = document.querySelector('.product_name, #product_name, h1')?.textContent?.trim();
  var productPrice = document.querySelector('.product_price, .price, [itemprop="price"]')?.getAttribute('content')
    || document.querySelector('.product_price, .price')?.textContent?.replace(/[^0-9.]/g, '');
  var productCode = document.querySelector('[itemprop="sku"], .product_code')?.textContent?.trim();

  if (productName) {
    window.dataLayer = window.dataLayer || [];
    window.dataLayer.push({
      'event': 'view_item',
      'ecommerce': {
        'items': [{
          'item_id': productCode || '',
          'item_name': productName,
          'price': parseFloat(productPrice) || 0
        }]
      }
    });
  }
});
</script>

Category Page Data Layer

<script>
document.addEventListener('DOMContentLoaded', function() {
  var items = [];
  document.querySelectorAll('.v-product, .product-item').forEach(function(el, i) {
    items.push({
      'item_name': el.querySelector('.v-product__title, .product-name a')?.textContent?.trim() || '',
      'price': parseFloat(el.querySelector('[itemprop="price"], .product-price')?.textContent?.replace(/[^0-9.]/g, '')) || 0,
      'index': i
    });
  });

  if (items.length) {
    window.dataLayer = window.dataLayer || [];
    window.dataLayer.push({
      'event': 'view_item_list',
      'ecommerce': { 'items': items }
    });
  }
});
</script>

E-commerce Tracking

Order Confirmation Page

Volusion's order confirmation page exposes limited order data. The approach depends on theme version:

Legacy themes -- look for rendered order details in the DOM:

<script>
document.addEventListener('DOMContentLoaded', function() {
  // Volusion renders order number and total on the confirmation page
  var orderNumber = document.querySelector('.order-number, #order_number')?.textContent?.trim();
  var orderTotal = document.querySelector('.order-total, .total-amount')?.textContent?.replace(/[^0-9.]/g, '');

  if (orderNumber) {
    window.dataLayer = window.dataLayer || [];
    window.dataLayer.push({
      'event': 'purchase',
      'ecommerce': {
        'transaction_id': orderNumber,
        'value': parseFloat(orderTotal) || 0,
        'currency': 'USD'
      }
    });
  }
});
</script>

V2 themes -- the confirmation page may use different CSS selectors. Inspect the rendered HTML to identify the correct elements.

Checkout Tracking Limitations

Volusion's checkout is a multi-step hosted flow. Key restrictions:

  • Scripts injected into the main template do not execute on secure checkout pages
  • There is no intermediate URL between cart and payment for tracking begin_checkout
  • The order confirmation page is the only reliable conversion tracking point
  • For checkout funnel tracking, use the cart page (which is part of the main storefront) as the entry point

Volusion API for Server-Side Tracking

The Volusion API provides order data for server-side event feeds:

GET https://store.volusion.com/net/WebService.aspx?Login=email&EncryptedPassword=hash&EDI_Name=Generic\Orders&SELECT_Columns=*

Or using the V2 REST API:

GET https://api.volusion.com/v1/orders
Authorization: Bearer {access_token}

Common Issues

Scripts not loading on checkout pages -- Volusion hosts checkout on a secure subdomain. Template scripts only execute on the main storefront. Place conversion tracking exclusively on the confirmation page.

DOM selectors breaking across themes -- Volusion themes use inconsistent CSS class names. Legacy themes, responsive themes, and V2 themes all have different markup structures. Test selectors against your specific theme.

Duplicate analytics from built-in GA -- If you use both the admin GA field and a manual GTM implementation, you will get duplicate pageviews. Disable the built-in GA when using GTM.

No structured data variables -- Unlike platforms such as Shopify or WooCommerce, Volusion does not inject structured JSON-LD or data attributes with product/order data. You must parse the visible DOM to extract values.

Cache-related stale data -- Volusion aggressively caches pages. Data layer values derived from DOM parsing may reflect cached content rather than the current page state. Use no-cache headers where possible or timestamp your data layer pushes.

Platform-Specific Considerations

V2 vs legacy themes -- Volusion has two distinct theme architectures. V2 themes use a modern component-based editor with different HTML structure. Legacy themes use a single monolithic template file. Your tracking implementation must match the active theme version.

File Editor limitations -- The File Editor in Volusion's admin provides direct template access, but certain system files are read-only. You can only modify the main template file and its CSS; JavaScript files may need to be hosted externally.

Article system for landing pages -- Volusion's article system allows creating static HTML pages with inline JavaScript. These can serve as standalone landing pages with custom tracking, but they use the same template wrapper as the rest of the site.

No tag manager integration -- Volusion has no native GTM or tag management integration. All tag management must be done through manual template editing.

Limited event hooks -- There are no client-side JavaScript hooks for cart interactions (add to cart, quantity change, remove). Tracking these events requires attaching event listeners to specific DOM elements, which may break when Volusion updates their frontend code.

Nach oben