server side tracking

SDX VISION

SDX VISION

November 28, 2025

Server-side tracking sends data directly from your server to analytics platforms, bypassing browsers and improving data accuracy, privacy compliance, and ad performance. This guide will teach you how to implement server-side tracking.

What is Server-Side Tracking?

Server-side tracking sends tracking data from your server to analytics and advertising platforms instead of from the user's browser.

How It Works:

User action occurs (purchase, form submit, etc.)
Your server processes the action
Server sends event data to platforms
Analytics platforms receive data
Data is recorded and attributed

Benefits:

Better Data Accuracy: Not blocked by ad blockers
Privacy Compliance: More control over data
Improved Performance: Reduces client-side code
Enhanced Security: Server-to-server communication
Better Attribution: More reliable tracking

When to Use Server-Side Tracking

Use Cases:

1. E-commerce Tracking:

Purchase events
Transaction data
Product information
Revenue tracking

2. Form Submissions:

Lead generation
Contact forms
Newsletter signups
Download tracking

3. User Actions:

Account creation
Login events
Profile updates
Subscription changes

4. Custom Events:

Business-specific actions
Complex conversions
Multi-step processes
Server-side validations

Server-Side Tracking Setup

Step 1: Choose Implementation Method

Option 1: Google Tag Manager Server-Side

Benefits:

Easy setup
Visual interface
Built-in templates
Good documentation

Option 2: Direct API Integration

Benefits:

Full control
Custom implementation
No dependencies
Flexible

Option 3: Third-Party Solutions

Benefits:

Pre-built solutions
Support included
Faster implementation
Managed service

Step 2: Set Up Google Tag Manager Server-Side

Prerequisites:

Google Cloud Platform account
Server/container setup
Domain configuration
SSL certificate

Setup Process:

1. Create Server Container:

Go to Tag Manager
Create new container
Choose "Server" container type
Configure settings

2. Set Up Server:

Deploy to Google Cloud Run
Or use your own server
Configure domain
Set up SSL

3. Configure Client:

Update GTM container
Add server container URL
Configure tags
Test implementation

Step 3: Configure Facebook Conversions API

Setup Process:

1. Get API Credentials:

Access Token
Pixel ID
Test Event Code

2. Implement Server-Side:

// Example Node.js implementation
const sendEvent = async (eventData) => {
  const response = await fetch(
    `https://graph.facebook.com/v18.0/${pixelId}/events`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        data: [{
          event_name: eventData.eventName,
          event_time: Math.floor(Date.now() / 1000),
          user_data: {
            em: hashEmail(eventData.email),
            ph: hashPhone(eventData.phone),
            external_id: eventData.userId
          },
          custom_data: eventData.customData
        }],
        access_token: accessToken
      })
    }
  );
  return response.json();
};

3. Match Client and Server Events:

Use event_id for deduplication
Send same event_id from client and server
Prevents double counting
Ensures accuracy

Step 4: Set Up Google Analytics 4 Server-Side

Implementation:

1. Measurement Protocol:

const sendGA4Event = async (eventData) => {
  const response = await fetch(
    `https://www.google-analytics.com/mp/collect?api_secret=${apiSecret}&measurement_id=${measurementId}`,
    {
      method: 'POST',
      body: JSON.stringify({
        client_id: eventData.clientId,
        events: [{
          name: eventData.eventName,
          params: eventData.params
        }]
      })
    }
  );
  return response;
};

2. Configure Events:

Set up conversion events
Configure parameters
Test event sending
Verify in GA4

Implementation Examples

E-commerce Purchase Tracking

Server-Side Implementation:

// After successful purchase
app.post('/purchase', async (req, res) => {
  const order = await processPurchase(req.body);
  
  // Send to Facebook Conversions API
  await sendFacebookEvent({
    eventName: 'Purchase',
    email: order.email,
    phone: order.phone,
    customData: {
      value: order.total,
      currency: 'USD',
      content_ids: order.productIds,
      contents: order.products
    }
  });
  
  // Send to GA4
  await sendGA4Event({
    eventName: 'purchase',
    params: {
      transaction_id: order.id,
      value: order.total,
      currency: 'USD',
      items: order.items
    }
  });
  
  res.json({ success: true });
});

Form Submission Tracking

Implementation:

app.post('/contact', async (req, res) => {
  const formData = req.body;
  
  // Process form
  await saveFormSubmission(formData);
  
  // Track as lead
  await sendFacebookEvent({
    eventName: 'Lead',
    email: formData.email,
    customData: {
      content_name: 'Contact Form',
      content_category: 'Lead Generation'
    }
  });
  
  await sendGA4Event({
    eventName: 'generate_lead',
    params: {
      value: 0,
      currency: 'USD'
    }
  });
  
  res.json({ success: true });
});

Data Privacy and Compliance

GDPR Compliance:

Requirements:

Get user consent
Process data lawfully
Secure data transmission
Allow data deletion
Provide transparency

Implementation:

Check consent before tracking
Hash PII data
Secure API calls
Implement data deletion
Document data usage

CCPA Compliance:

Requirements:

Disclose data collection
Allow opt-out
Secure data
Delete on request

Implementation:

Privacy policy updates
Opt-out mechanism
Secure storage
Deletion process

Data Hashing:

Why Hash:

Privacy protection
Platform requirements
Compliance
Security

How to Hash:

const crypto = require('crypto');

const hashEmail = (email) => {
  const normalized = email.toLowerCase().trim();
  return crypto.createHash('sha256')
    .update(normalized)
    .digest('hex');
};

const hashPhone = (phone) => {
  const normalized = phone.replace(/\D/g, '');
  return crypto.createHash('sha256')
    .update(normalized)
    .digest('hex');
};

Event Deduplication

Why Deduplicate:

Problem: Same event sent from client and server

Solution: Use event_id to deduplicate

Implementation:

Client-Side:

// Generate event_id
const eventId = generateUUID();

// Send to server
gtag('event', 'purchase', {
  transaction_id: orderId,
  event_id: eventId
});

// Send to your server
fetch('/track-purchase', {
  method: 'POST',
  body: JSON.stringify({
    orderId: orderId,
    eventId: eventId
  })
});

Server-Side:

// Use same event_id
await sendFacebookEvent({
  eventName: 'Purchase',
  eventId: eventData.eventId, // Same ID from client
  // ... other data
});

Testing Server-Side Tracking

Testing Methods:

1. Test Events:

Use test event codes
Verify in platforms
Check data accuracy
Validate parameters

2. Debug Mode:

Enable debug mode
Check event logs
Verify data format
Test error handling

3. Validation:

Compare client and server events
Check deduplication
Verify data accuracy
Test edge cases

Testing Checklist:

[ ] Events sending successfully
[ ] Data format correct
[ ] Events appearing in platforms
[ ] Deduplication working
[ ] Error handling implemented
[ ] Performance acceptable
[ ] Privacy compliance verified

Best Practices

1. Use Both Client and Server

Hybrid Approach:

Client-side for real-time
Server-side for accuracy
Deduplicate events
Best of both worlds

2. Hash PII Data

Always Hash:

Email addresses
Phone numbers
Names (if required)
Other PII

3. Implement Error Handling

Error Handling:

Retry failed requests
Log errors
Monitor failures
Alert on issues

4. Monitor Performance

Metrics:

Event send success rate
Latency
Error rates
Data accuracy

5. Regular Testing

Schedule:

Test after changes
Weekly validation
Monthly audit
Quarterly review

Common Issues and Solutions

Issue 1: Events Not Appearing

Solutions:

Check API credentials
Verify event format
Check network logs
Validate parameters

Issue 2: Duplicate Events

Solutions:

Implement event_id
Use deduplication
Check both client and server
Verify matching logic

Issue 3: Data Mismatch

Solutions:

Compare client and server data
Check data transformation
Verify parameter mapping
Validate data format

Server-Side Tracking Checklist

[ ] Implementation method chosen
[ ] Server container set up (if GTM)
[ ] API credentials obtained
[ ] Events implemented
[ ] Deduplication configured
[ ] Data hashing implemented
[ ] Error handling added
[ ] Testing completed
[ ] Monitoring set up
[ ] Documentation created

Next Steps

Choose Method: Select implementation approach
Set Up Infrastructure: Configure server/container
Implement Events: Code tracking events
Test Thoroughly: Validate implementation
Monitor Performance: Track success rates
Optimize: Improve based on data

Thanks for reading the blog. If you want more help, do contact us at https://sdx.vision

Blog.

server side tracking

What is Server-Side Tracking?

How It Works:

Benefits:

When to Use Server-Side Tracking

Use Cases:

Server-Side Tracking Setup

Step 1: Choose Implementation Method

Step 2: Set Up Google Tag Manager Server-Side

Step 3: Configure Facebook Conversions API

Step 4: Set Up Google Analytics 4 Server-Side

Implementation Examples

E-commerce Purchase Tracking

Form Submission Tracking

Data Privacy and Compliance

GDPR Compliance:

CCPA Compliance:

Data Hashing:

Event Deduplication

Why Deduplicate:

Implementation:

Testing Server-Side Tracking

Testing Methods:

Testing Checklist:

Best Practices

1. Use Both Client and Server

2. Hash PII Data

3. Implement Error Handling

4. Monitor Performance

5. Regular Testing

Common Issues and Solutions

Issue 1: Events Not Appearing

Issue 2: Duplicate Events

Issue 3: Data Mismatch

Server-Side Tracking Checklist

Next Steps