Adobe Advertising Cloud Server-Side vs Client-Side | OpsBlu Docs

Adobe Advertising Cloud Server-Side vs Client-Side

Architectural decisions and trade-offs for client-side conversion tags and server-side Conversion API collection.

When to Use Client-Side Collection (Conversion Tags)

Client-side tracking via Adobe Advertising Cloud conversion tags is the standard approach for web-based conversions. Use client-side collection when:

  • Tracking user conversions that occur in the browser (purchases, form submissions, registrations).
  • Using automatic visitor identification via Adobe Experience Cloud ID Service (ECID).
  • Implementing with minimal backend infrastructure (tags can be deployed via GTM or direct embed).
  • Capturing real-time conversion events with immediate visibility in reporting.
  • Benefiting from automatic integration with Adobe Analytics for Advertising.

Client-Side Advantages

  • Easy to implement via tag managers without backend development.
  • Automatic visitor identification using ECID for cross-device tracking.
  • Real-time conversion tracking with immediate reporting availability.
  • Feeds conversion data directly into Adobe Analytics for multi-touch attribution.
  • Captures user context automatically (referrer, page URL, user agent).
  • Native support for viewthrough conversion attribution.

Client-Side Limitations

  • Vulnerable to ad blockers and browser privacy features (Intelligent Tracking Prevention, Enhanced Tracking Protection).
  • Cookie deletion or blocking can reduce attribution accuracy.
  • Cannot track backend events that occur outside the browser (subscription renewals, offline conversions).
  • Subject to consent requirements (GDPR, CCPA) that may limit data collection.
  • Page abandonment before tag loads results in lost conversion data.
  • Requires user to complete action on page where tag is implemented.

When to Use Server-Side Collection (Conversion API)

Server-side tracking via Adobe Advertising Cloud Conversion API sends events directly from your server, bypassing browser limitations. Use server-side collection when:

  • Sending high-value conversions that must be tracked reliably (purchases, subscriptions, high-value leads).
  • Tracking backend events that occur outside the browser (order confirmations, payment processing, fulfillment).
  • Mitigating data loss from ad blockers, consent denials, or browser privacy features.
  • Implementing privacy-compliant tracking with full control over data sent.
  • Supplementing client-side tags to improve attribution accuracy and completeness.

Server-Side Advantages

  • Not affected by ad blockers or browser privacy features.
  • Full control over conversion timing, parameters, and data sent to Adobe.
  • Can track backend events invisible to the browser (subscription renewals, offline conversions, backend validations).
  • Reduces data loss from page abandonment or client-side errors.
  • Enables tracking of events after user leaves site (delayed order processing, multi-step fulfillment).
  • Better privacy compliance by controlling exactly what data is transmitted and when.

Server-Side Limitations

  • Requires backend development and infrastructure to send API requests.
  • Must manually collect and pass visitor identification data (ECID, customer ID, device data).
  • No automatic visitor identification; relies on ECID or customer ID matching.
  • Attribution may be less precise if visitor data is incomplete or missing.
  • Requires coordination with client-side implementation to capture ECID and pass to server.
  • Additional complexity in debugging and validation compared to client-side tags.

Coordination & Deduplication

The recommended approach is a dual implementation: client-side tags for real-time tracking + server-side API for reliable backend conversions, with deduplication to avoid double-counting.

Deduplication Strategy

  • Send the same high-value conversions from both client-side tags and server-side API.
  • Include unique transaction ID (order ID) in both client and server conversion events.
  • Adobe Advertising Cloud automatically deduplicates conversions with identical transaction IDs within 30-day window.
  • Server-side conversion takes precedence if both fire (provides authoritative backend-validated data).

Example:

  • Client-side tag: Fires on order confirmation page with order ID "ORDER12345", revenue $99.99.
  • Server-side API: Sends POST request after payment confirmation with same order ID "ORDER12345", revenue $99.99.
  • Result: Adobe Advertising Cloud counts one conversion, using server-side data as authoritative source.

Data Richness Strategy

  • Client-side: Captures automatic visitor context (ECID, referrer, landing page, user agent, click IDs).
  • Server-side: Sends validated transaction data (final order total, payment status, backend-verified details).
  • Combined: Client-side provides attribution context, server-side ensures conversion accuracy and completeness.

Visitor Matching Strategy

  • Client-side: Automatically uses ECID from Adobe Experience Cloud ID Service.
  • Server-side: Must explicitly pass ECID, customer ID, or hashed email for visitor matching.
  • Best practice: Capture ECID in browser session and pass to backend for API calls.

Architectural Patterns

Pattern 1: Client-Side Only (Basic)

  • Deploy Adobe Advertising Cloud conversion tags via GTM for all conversion events.
  • Use for simple websites with no backend infrastructure or low conversion volumes.
  • Accept data loss from ad blockers and browser privacy features as acceptable risk.
  • Suited to: Testing, small campaigns, or organizations without backend development resources.

Pattern 2: Dual Client + Server (Recommended)

  • Deploy client-side tags for immediate conversion tracking and automatic attribution.
  • Deploy server-side API for high-value conversions after backend validation.
  • Use transaction ID deduplication so Adobe counts each conversion once.
  • Suited to: E-commerce, lead generation, subscription businesses with backend order processing.

Pattern 3: Server-Side Only (Privacy-First)

  • Skip client-side tags; send all conversions server-side via API.
  • Collect consent, then pass ECID or customer ID for visitor matching.
  • Requires backend tracking infrastructure (event queue, retry logic, ECID storage) and manual attribution data collection.
  • Suited to: Privacy-sensitive industries, regulated sectors, or sites where ad blockers block 20%+ of client-side tags.

Pattern 4: Hybrid with Adobe Analytics

  • Use Adobe Analytics for Advertising integration for unified tracking.
  • Client-side tags feed Adobe Analytics; Analytics shares conversion data with Advertising Cloud.
  • Enables multi-touch attribution and cross-channel journey analysis.
  • Suited to: Organizations already using Adobe Analytics with mature analytics implementation.

ECID Collection and Passing

For server-side conversion tracking to work effectively, you must collect ECID from the browser and pass to your backend:

// Client-side: Capture ECID and send to backend
var visitor = Visitor.getInstance("YOUR_ORG_ID@AdobeOrg");
visitor.getMarketingCloudVisitorID(function(ecid) {
  // Store in hidden form field
  document.getElementById('ecid_field').value = ecid;

  // Or send via AJAX to backend
  fetch('/api/store-ecid', {
    method: 'POST',
    body: JSON.stringify({ ecid: ecid })
  });
});

# Server-side: Retrieve ECID and include in conversion API call
ecid = request.session.get('ecid')

conversion_payload = {
    "advertiser_id": "ADVERTISER_ID",
    "conversion_id": "CONVERSION_ID",
    "transaction_id": order_id,
    "transaction_value": order_total,
    "currency": "USD",
    "visitor_data": {
        "ecid": ecid,
        "customer_id": customer_id,
        "email_hash": hash_email(customer_email)
    }
}

# Send to Adobe Advertising Cloud Conversion API
response = requests.post(
    "https://api.advertising.adobe.io/conversions",
    json=conversion_payload,
    headers={"Authorization": f"Bearer {access_token}"}
)

Implementation Checklist

  • Client-side: Confirm conversion tags fire on completion pages, parameters are correct, and ECID is present.
  • Server-side: Verify API endpoint is live, conversions appear in reports, and visitor matching is successful.
  • Deduplication: Test that sending same conversion from both client and server results in single counted conversion.
  • Visitor matching: Ensure ECID or customer ID is passed from browser to server and included in API calls.
  • Consent: Confirm both client and server implementations respect user consent choices.

When to Choose One Over the Other

  • Choose client-side only if you have no backend resources, low conversion volumes, or are testing Adobe Advertising Cloud initially.
  • Choose server-side only if browser tracking is unreliable, you need full data control, or privacy regulations restrict client-side tracking.
  • Choose dual client + server for most production use cases to maximize attribution accuracy, reduce data loss, and ensure conversion completeness.

Adobe Analytics Integration Considerations

If using Adobe Analytics for Advertising:

  • Client-side conversion tags automatically integrate with Adobe Analytics when AMO ID is captured.
  • Server-side conversions can be mirrored to Adobe Analytics via Data Insertion API or Processing Rules.
  • Enable bidirectional data sharing: Analytics provides multi-touch attribution, Advertising Cloud provides media performance.
  • Use Analysis Workspace to build unified reports combining Analytics behavior data with Advertising Cloud campaign data.

Implementation Guidance

Event routing: Send high-value conversions (purchases, subscriptions, leads) through both client-side tags and server-side API for maximum reliability. Send lower-value behavioral events (page views, product views) through client-side only to minimize server-side infrastructure costs.

ECID forwarding: Capture the Experience Cloud ID (ECID) from the AMCV_ cookie on each server request. Pass it in your server-side API calls as the marketingCloudVisitorId parameter. Without ECID, server-side conversions cannot be matched to client-side user journeys, breaking cross-channel attribution.

Unified tracking: For new implementations, use Adobe Experience Platform Web SDK (alloy.js) which handles both client-side and server-side event collection through a single integration. It replaces the need for separate AppMeasurement.js and conversion tag implementations.

Monitoring: Check Adobe Advertising Cloud Reports daily for conversion tag health. Set up alerts for drops in conversion volume exceeding 20%, which typically indicate tag deployment issues or consent changes affecting event collection.

Nach oben