DV360 Server-Side vs Client-Side Tracking | OpsBlu Docs

DV360 Server-Side vs Client-Side Tracking

Comparison of server-side and client-side Floodlight implementation options for DV360.

Overview

Floodlight conversions can be recorded via client-side tags (browser-based JavaScript) or server-side API calls. Each approach has distinct advantages, limitations, and use cases. Many implementations use a hybrid approach for optimal coverage.

Client-Side Tracking (Default)

How It Works

JavaScript tags execute in the user's browser and send conversion data directly to Google's servers via HTTP requests.

Technology stack:

  • Floodlight global site tag (gtag.js)
  • Google Tag Manager
  • Browser cookies (_gcl_dc)
  • Client-side JavaScript

Implementation

<!-- Global site tag -->
<script async src="https://www.googletagmanager.com/gtag/js?id=DC-XXXXXXXX"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());
  gtag('config', 'DC-XXXXXXXX');
</script>

<!-- Event tag -->
<script>
  gtag('event', 'conversion', {
    'allow_custom_scripts': true,
    'value': 99.99,
    'transaction_id': 'ORDER123',
    'send_to': 'DC-XXXXXXXX/invmedia/purchase0+standard'
  });
</script>

Advantages

Easy Implementation:

  • Simple copy-paste tag deployment
  • No backend development required
  • GTM provides user-friendly interface
  • Quick testing and iteration

Automatic Data Collection:

  • User-agent, IP address, referrer captured automatically
  • Browser cookies for attribution
  • Device and browser information
  • Geographic data from IP

Real-Time Tracking:

  • Immediate conversion recording
  • No server latency
  • Direct communication with Google servers

Cost-Effective:

  • No server infrastructure required
  • No API rate limits or quotas
  • Included in DV360 platform

Limitations

Browser Dependency:

  • Requires JavaScript enabled
  • Blocked by ad blockers (10-30% of users)
  • Privacy extensions interfere with tracking
  • Cookie deletion breaks attribution

Privacy Restrictions:

  • Safari ITP limits cookie lifespan (7 days)
  • Firefox Enhanced Tracking Protection
  • GDPR consent required in EU
  • Third-party cookie phase-out impact

Data Loss:

  • Users leaving page before tag fires
  • Network issues preventing tag load
  • Mobile app conversions harder to track
  • Bot traffic and fraud detection challenges

Limited Control:

  • Can't track conversions without page load
  • Difficult to deduplicate across channels
  • No access to backend data (subscription status, LTV)
  • Timing dependent on page load performance

Server-Side Tracking

How It Works

Your server sends conversion data directly to Google via Floodlight API, bypassing the user's browser.

Technology stack:

  • Campaign Manager 360 Conversions API
  • Backend server (Node.js, Python, PHP, etc.)
  • Server-side cookie storage or user ID matching
  • API authentication

Implementation

Using Conversions API

// Node.js example
const axios = require('axios');

async function recordFloodlightConversion(conversionData) {
  const endpoint = 'https://www.googlesyndication.com/pagead/conversion/XXXXXXXX/';

  const params = {
    src: 'XXXXXXXX',           // Floodlight configuration ID
    type: 'invmedia',          // Activity group
    cat: 'purchase0',          // Activity tag string
    qty: 1,
    cost: conversionData.value,
    ord: conversionData.orderId,
    u1: conversionData.category,
    u2: conversionData.customerType,
    // Click ID for attribution (from landing page URL)
    gclid: conversionData.gclid,
    // Or encrypted user ID
    uid: conversionData.hashedEmail,
  };

  try {
    const response = await axios.get(endpoint, { params });
    console.log('Conversion recorded:', response.status);
  } catch (error) {
    console.error('Error recording conversion:', error);
  }
}

// Usage
recordFloodlightConversion({
  value: 149.99,
  orderId: 'ORD-2024-12345',
  category: 'electronics',
  customerType: 'returning',
  gclid: 'CjwKCAiA...',  // Captured from landing page
});

Using Server-Side GTM

Google Tag Manager Server-Side container:

// Server GTM client template
const claimRequest = require('claimRequest');
const returnResponse = require('returnResponse');

claimRequest();

// Extract conversion data from request
const eventData = {
  config_id: 'DC-XXXXXXXX',
  activity_group: 'invmedia',
  activity_tag: 'purchase0',
  value: request.body.value,
  transaction_id: request.body.orderId,
  u1: request.body.category,
};

// Send to Floodlight
sendHttpRequest('https://ad.doubleclick.net/ddm/activity/...', {
  method: 'GET',
  queryParams: eventData,
});

returnResponse({ status: 200 });

Advantages

Reliability:

  • Not blocked by ad blockers
  • Doesn't depend on JavaScript or cookies
  • Immune to browser privacy features
  • 100% conversion capture (no client-side failures)

Enhanced Privacy:

  • No third-party cookies required
  • Control over what data is sent
  • Can hash PII before transmission
  • GDPR-friendly with consent management

Access to Backend Data:

  • Include subscription status
  • Customer lifetime value
  • Offline conversion data
  • CRM enrichment
  • Fraud detection scores

Deduplication & Control:

  • Prevent duplicate conversions server-side
  • Validate transactions before recording
  • Cross-channel attribution with unified user ID
  • Better data quality control

Future-Proof:

  • Less impacted by cookie deprecation
  • Works in cookieless environments
  • Compatible with emerging privacy standards

Limitations

Development Required:

  • Backend integration necessary
  • API expertise needed
  • More complex setup and testing
  • Ongoing maintenance

Attribution Challenges:

  • Must capture and store click ID (gclid) or user ID
  • Requires database to match users to clicks
  • More complex cross-device tracking
  • No automatic IP/user-agent data

Infrastructure Costs:

  • Server resources required
  • Monitoring and logging overhead
  • Potential API rate limits
  • Increased complexity

Testing & Debugging:

  • Harder to test than client-side
  • No browser devtools visibility
  • Requires backend logging
  • Delayed error detection

Combine client-side and server-side for maximum coverage and reliability.

Implementation Strategy

Client-Side (Primary):

  • Deploy standard Floodlight tags via GTM
  • Capture majority of conversions
  • Collect click IDs and store server-side

Server-Side (Fallback & Enhancement):

  • Catch conversions missed by client-side
  • Record offline or delayed conversions
  • Deduplicate using transaction IDs
  • Enrich with backend data

Example Flow

  1. User clicks DV360 ad → lands on site
  2. Client-side: Global tag fires, sets _gcl_dc cookie
  3. Client-side: GCLID stored in database with user session
  4. User completes purchase
  5. Client-side: Floodlight conversion tag fires (immediate)
  6. Server-side: Order confirmed in backend system
  7. Server-side: API call to Floodlight (if client-side failed or for enrichment)
  8. Deduplication: Transaction ID prevents double-counting

Code Example: Hybrid Implementation

// Client-side: Standard tag + GCLID capture
gtag('event', 'conversion', {
  'allow_custom_scripts': true,
  'value': 199.99,
  'transaction_id': 'ORDER-456',
  'send_to': 'DC-XXXXXXXX/invmedia/purchase0+transactions'
});

// Also send GCLID to backend
fetch('/api/store-conversion', {
  method: 'POST',
  body: JSON.stringify({
    orderId: 'ORDER-456',
    gclid: getCookie('_gcl_dc'),
    value: 199.99
  })
});

// Server-side: Fallback after 30 seconds
setTimeout(async () => {
  const conversion = await db.getConversion('ORDER-456');
  if (!conversion.clientSideRecorded) {
    // Client-side failed, send server-side
    await recordFloodlightConversion(conversion);
  }
}, 30000);

Use Case Recommendations

Use Client-Side When:

  • Standard e-commerce website conversions
  • Lead generation forms
  • Content engagement tracking
  • Small to medium traffic volume
  • Limited development resources
  • Fast implementation needed

Use Server-Side When:

  • Subscription renewals (no user action)
  • Offline conversions (phone orders, in-store)
  • Mobile app conversions
  • High ad-blocker audience (tech industry)
  • CRM-integrated conversion tracking
  • Enterprise-level data quality requirements
  • Multi-touch attribution across platforms

Use Hybrid Approach When:

  • Maximum conversion coverage required
  • Both online and offline conversions
  • Attribution accuracy is critical
  • High-value transactions
  • Complex customer journeys
  • Regulatory compliance needs (healthcare, finance)

Migration Strategy

From Client-Side to Hybrid

Phase 1: Preparation

  1. Audit current client-side implementation
  2. Capture and store GCLIDs in database
  3. Set up server infrastructure
  4. Test server-side API in staging

Phase 2: Parallel Tracking

  1. Deploy server-side alongside client-side
  2. Use different transaction ID prefixes to identify source
  3. Monitor both implementations
  4. Compare conversion volumes

Phase 3: Optimization

  1. Implement deduplication logic
  2. Configure server-side as fallback only
  3. Enrich with backend data
  4. Remove redundant client-side tags (if desired)

Best Practices

Client-Side:

  • Use GTM for easier management
  • Implement consent mode for privacy
  • Test with ad blockers enabled
  • Monitor tag health in Tag Assistant
  • Set up alerts for tag failures

Server-Side:

  • Always capture and store click IDs
  • Implement transaction ID deduplication
  • Hash PII before sending to API
  • Log all API calls for debugging
  • Set up retry logic for failed requests
  • Monitor API response codes

Hybrid:

  • Use transaction IDs consistently across both methods
  • Implement server-side deduplication
  • Set client-side as primary, server-side as fallback
  • Enrich server-side conversions with backend data
  • Test both paths regularly
  • Monitor for double-counting

Privacy & Compliance

Client-Side:

Server-Side:

  • Still requires consent for personal data processing
  • More control over data sent
  • Hash emails and user IDs
  • Document data flows for GDPR
  • Implement right to erasure for stored click IDs

Performance Considerations

Client-Side:

  • Async tag loading to avoid blocking page
  • Minimize custom variable complexity
  • Use GTM's built-in tag sequencing
  • Monitor page load impact

Server-Side:

  • Asynchronous API calls (don't block user experience)
  • Implement caching for GCLID lookups
  • Rate limiting for API calls
  • Error handling and retry logic
  • Monitor API latency and failures

Conclusion

Neither client-side nor server-side is universally superior. The optimal approach depends on:

  • Your technical resources
  • Audience characteristics (ad blocker usage)
  • Privacy requirements
  • Attribution accuracy needs
  • Budget and timeline

For most organizations, a hybrid approach provides the best balance of coverage, accuracy, and future-proofing as the digital advertising landscape evolves toward privacy-first tracking.

Nach oben