DV360 Server-Side vs Client-Side Tracking

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

Hybrid Approach (Recommended)

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:

• Requires user consent in EU
• Disclose in privacy policy
• Implement consent management platform
• Use Consent Mode API

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.