Adobe Analytics: AppMeasurement, eVars,

How Adobe Analytics Works

Adobe Analytics uses a server-call model. Every tracked interaction sends an HTTP image request (a "server call") to Adobe's data collection servers. There are two types of server calls: page view calls (s.t()) and link tracking calls (s.tl()). Each server call carries a payload of variables, dimensions, and metrics that Adobe processes and stores.

The data model is built on three variable types:

• Props (Traffic Variables) -- prop1 through prop75. Props are hit-scoped, meaning they apply only to the server call where they are set. They support pathing (showing the sequence of values a user passes through) and correlations, but they do not persist across hits.

• eVars (Conversion Variables) -- eVar1 through eVar250. eVars persist beyond the hit where they are set, based on a configurable expiration: visit, time-based (up to 90 days), or on a specific success event. This persistence is what lets you attribute a conversion event back to a campaign click that happened earlier in the session or across sessions.

• Events (Success Events) -- event1 through event1000. Events are numeric counters or currency values that represent business outcomes: purchases, registrations, video plays, etc. Events are always associated with the eVars and props that were active when the event fired.

When Adobe's servers receive a server call, they run processing rules that can copy, modify, or populate variables before the data is stored. This allows you to map context data variables (freeform key-value pairs sent in the request) to specific props, eVars, or events without changing the client-side implementation.

Adobe processes data through a pipeline that applies VISTA rules (server-side processing), segmentation, and attribution models before writing to the reporting database. Standard reports are available within 30-90 minutes. Real-time reports show data within seconds but support a limited set of metrics.

Installing the Tracking Library

Adobe Analytics supports two collection libraries: the legacy AppMeasurement.js and the newer Adobe Experience Platform Web SDK (alloy.js).

AppMeasurement.js

Download AppMeasurement.js from Adobe Analytics Admin > Code Manager, or deploy it through Adobe Launch (Experience Platform Tags). The base configuration:

<script src="//cdn.example.com/AppMeasurement.js"></script>
<script>
  var s = s_gi('YOUR-REPORT-SUITE-ID');

  // Required configuration
  s.trackingServer = 'metrics.example.com';    // Your tracking domain
  s.trackingServerSecure = 'smetrics.example.com'; // HTTPS tracking domain
  s.account = 'your-report-suite-id';

  // Optional: Visitor ID Service (ECID)
  s.visitor = Visitor.getInstance('YOUR-ORG-ID@AdobeOrg');

  // Page variables
  s.pageName = document.title;
  s.channel = 'Technology';
  s.server = window.location.hostname;

  // Send the page view
  s.t();
</script>

The s.t() call sends a page view server call. It constructs an image request to https://smetrics.example.com/b/ss/your-report-suite-id/1/JS-2.x.x/s12345678?... with all variables encoded as query parameters.

Web SDK (alloy.js)

The Web SDK replaces AppMeasurement and sends data to Adobe Experience Platform Edge Network, which routes it to Analytics, Target, Audience Manager, and other Adobe solutions simultaneously:

<script src="https://cdn1.adoberesources.net/alloy/2.x.x/alloy.min.js" async></script>
<script>
  alloy('configure', {
    datastreamId: 'YOUR-DATASTREAM-ID',
    orgId: 'YOUR-ORG-ID@AdobeOrg',
    defaultConsent: 'in'
  });

  // Send a page view
  alloy('sendEvent', {
    xdm: {
      web: {
        webPageDetails: {
          name: document.title,
          URL: window.location.href
        },
        webInteraction: {
          type: 'other'
        }
      }
    },
    data: {
      __adobe: {
        analytics: {
          prop1: 'Technology',
          eVar5: 'campaign-123',
          events: 'event1'
        }
      }
    }
  });
</script>

The Web SDK sends data as XDM (Experience Data Model) JSON payloads to edge.adobedc.net. The datastream configuration on the server side maps XDM fields to Analytics variables.

Verifying Installation

For AppMeasurement, open DevTools Network tab and filter for your tracking server domain (smetrics.example.com or 2o7.net). Each server call appears as an image request. The query parameters contain the variables: pageName, v1 (eVar1), c1 (prop1), pe (link type), etc.

For the Web SDK, filter for edge.adobedc.net. Requests are POST with JSON payloads. Install the Adobe Experience Platform Debugger Chrome extension to see a parsed view of all variables being sent.

Event Tracking and Data Collection

Page View Tracking (s.t)

s.t() sends a page view server call. It increments the Page Views metric and records all variables that are currently set on the s object:

s.pageName = 'Product Detail: Widget Pro';
s.channel = 'Products';
s.prop1 = 'Widget Pro';
s.eVar1 = 'product-detail';
s.eVar10 = 'logged-in';
s.products = ';Widget Pro;1;49.99;event1=49.99';
s.events = 'prodView,event1';
s.t();

Link Tracking (s.tl)

s.tl() sends a non-page-view server call for tracking clicks, downloads, and custom interactions without incrementing Page Views:

// Track a custom link click
s.tl(this, 'o', 'CTA Click: Start Trial', null, function(){
  // Callback after the tracking request completes
});

// Track a download
s.tl(this, 'd', 'PDF Download: Whitepaper');

// Track an exit link
s.tl(this, 'e', 'Exit: Partner Site');

The second parameter is the link type: 'o' (custom), 'd' (download), 'e' (exit). The third is the link name that appears in reports.

Context Data and Processing Rules

Instead of setting props and eVars directly in JavaScript, you can send freeform context data variables and map them server-side using Processing Rules:

// Send context data
s.contextData['page.section'] = 'Technology';
s.contextData['user.type'] = 'premium';
s.contextData['content.author'] = 'Jane Martinez';
s.t();

In the Adobe Analytics Admin > Processing Rules, create rules like:

• Set prop1 to context data: page.section
• Set eVar5 to context data: user.type
• Set eVar10 to context data: content.author

This decouples the implementation from the variable mapping, allowing analysts to remap variables without deploying code changes.

The Products String

The s.products variable uses a specific delimited format for e-commerce tracking:

// Format: Category;Product;Quantity;Price;Events;Merchandising eVars
s.products = 'Shoes;Running Shoe XL;1;89.99;event1=89.99|event2=1;eVar10=blue|eVar11=size-12';
s.events = 'purchase,event1,event2';
s.t();

Multiple products are separated by commas. The semicolons delimit fields within each product entry.

Identity and User Tracking

Adobe Analytics identifies users through the Experience Cloud ID (ECID), managed by the Visitor ID Service:

// Initialize the Visitor ID Service
var visitor = Visitor.getInstance('YOUR-ORG-ID@AdobeOrg', {
  trackingServer: 'metrics.example.com',
  trackingServerSecure: 'smetrics.example.com'
});

The Visitor ID Service sets an AMCV_ cookie containing the ECID, a unique identifier that persists across the Adobe Experience Cloud. This same ID is shared by Analytics, Target, Audience Manager, and other Adobe solutions, enabling cross-solution identity stitching.

For authenticated users, set a Customer ID to link the ECID to your own user identifier:

visitor.setCustomerIDs({
  'crm_id': {
    id: 'USER_123',
    authState: Visitor.AuthState.AUTHENTICATED
  }
});

The authState can be UNKNOWN, AUTHENTICATED, or LOGGED_OUT. When set to AUTHENTICATED, Adobe syncs this Customer ID with the ECID in the Identity Service, enabling cross-device stitching via the Device Co-op or CDA (Cross-Device Analytics).

SAINT Classifications

SAINT (SiteCatalyst Attribute Importing and Naming Tool) lets you upload lookup tables that add metadata to existing variable values without modifying the implementation. For example, if eVar5 captures a campaign tracking code like sem_google_brand_q1, you can classify it into:

Upload classifications via the Classification Importer in Admin, the Classification Rule Builder (regex-based auto-classification), or the Classifications API:

# Upload a classification file via FTP
# File format: tab-delimited, first column is the key
ftp ftp.omniture.com
# Use credentials from Admin > Classification Importer > FTP Import

Classifications are retroactive. Uploading a new classification file immediately reclassifies all historical data for that variable.

API and Data Export

Data Feeds

Data Feeds export raw, hit-level data as tab-delimited files delivered hourly or daily to FTP or Amazon S3. Each row is a single server call with all variables. This is the Adobe Analytics equivalent of GA4's BigQuery export. Data Feeds include every hit, including bot traffic and excluded data, so you get the complete picture.

Reporting API 2.0

# Query a ranked report via the Analytics 2.0 API
curl -X POST "https://analytics.adobe.io/api/YOUR-COMPANY/reports" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "rsid": "your-report-suite-id",
    "globalFilters": [{
      "type": "dateRange",
      "dateRange": "2026-03-01T00:00:00/2026-03-04T00:00:00"
    }],
    "metricContainer": {
      "metrics": [
        {"id": "metrics/pageviews"},
        {"id": "metrics/visits"}
      ]
    },
    "dimension": "variables/evar5"
  }'

Data Warehouse

Data Warehouse generates large-scale exports with breakdowns that standard reports cannot handle. It processes requests asynchronously and delivers results as CSV files. Data Warehouse supports unlimited rows and can break down any variable by any other variable. Requests are submitted through the Analytics UI or API.

Common Issues

Platform-Specific Considerations

Report Suite architecture: Adobe Analytics uses report suites as data containers. A global report suite collects all data, while virtual report suites (VRS) apply segments to create filtered views without duplicating data. Multi-suite tagging (sending data to multiple report suites simultaneously) increases server call volume and cost.

Server call pricing: Adobe Analytics is priced by server call volume. Every s.t() and s.tl() call counts. Excessive link tracking, bot traffic, or multi-suite tagging can rapidly consume your allocation.

Data retention: Adobe retains data for 25 months by default on standard contracts. Data Warehouse queries can access the full retention period. Data Feeds include historical data based on your contract.

Processing order: Variables go through this pipeline: AppMeasurement > VISTA rules > Processing Rules > Report Time Processing (if enabled) > Reporting. Understanding this order matters when debugging variable values that appear differently in the debugger versus reports.

Related Guides

• Adobe Analytics Setup and Implementation
• Adobe Analytics Event Tracking
• Adobe Analytics Integrations
• Troubleshooting Adobe Analytics
• Adobe Analytics Setup and Implementation