Integrating Salesforce with Google Analytics 4 Using Apex Code

Posted on December 26th, 2024 by Anuj Agarwal

Understanding the Business Need

In today’s data-driven world, businesses need a unified view of customer interactions to make informed decisions. Salesforce, a leading CRM platform, captures a wealth of customer information. Google Analytics 4 (GA4), on the other hand, provides deep insights into user behavior on websites and mobile apps. Integrating these two platforms allows businesses to bridge the gap between offline (CRM) and online (web/app) data, enabling:

  • Enhanced Attribution: Combine offline lead data with online conversion events.
  • Unified Customer Journeys: Track user interactions across multiple touchpoints.
  • Data-Driven Campaign Optimization: Refine marketing efforts based on combined insights from Salesforce and GA4.

To address this need, we implemented an integration of Salesforce with GA4 using Apex code, enabling seamless data sharing between the platforms.

How We Did It

1. Setting Up GA4 Measurement Protocol

The GA4 Measurement Protocol API allows us to send event data directly to GA4 from a server. This API is critical for integrating Salesforce, as it lets us push Salesforce event data to GA4 programmatically.

2. Creating the Apex Code in Salesforce

We developed Apex classes and methods to:

  • Construct GA4 Measurement Protocol payloads.
  • Make HTTP POST requests to the GA4 endpoint.
  • Handle potential errors and retries.

Key features of the Apex implementation include:

  • Event Mapping: Mapping Salesforce events (e.g., lead creation, status updates) to GA4 events.
  • Data Transformation: Formatting Salesforce data to match GA4's event structure.
  • Error Handling: Logging and retry mechanisms for failed requests.

3. Setting Up Custom Metadata for Configurations

We used Custom Metadata Types in Salesforce to store GA4 configurations, such as:

  • Measurement ID and API secret for GA4.
  • Event mappings between Salesforce and GA4.

This approach ensures flexibility and scalability without hardcoding values.

4. Triggering the Integration

We leveraged Salesforce triggers and schedulable classes to initiate the integration:

  • Triggers: For real-time updates, such as lead creation or opportunity stage changes.
  • Batch Jobs: For bulk processing of historical data.

5. Testing the Integration

We conducted end-to-end testing to ensure:

  • Accurate data transmission.
  • Proper mapping of Salesforce events to GA4.
  • Robust error handling under different scenarios.

Key Scenarios Covered

  • Real-Time Event Tracking:

    • Scenario: A lead is created in Salesforce.
    • Action: Trigger sends a “lead_created” event to GA4 with relevant details.
  • Opportunity Stage Updates:

    • Scenario: An opportunity moves to the "Closed Won" stage.
    • Action: An “opportunity_won” event is sent to GA4.
  • Error Handling:

    • Scenario: API call to GA4 fails due to network issues.
    • Action: Log the error and retry using a scheduled job.
  • Bulk Data Processing:

    • Scenario: Sync historical lead data to GA4.
    • Action: Use a batch job to send events in batches.
  • Data Validation:

    • Scenario: Invalid data is detected in the Salesforce record.
    • Action: Log the issue and skip the record.

Apex Code Example

Here’s a snippet of the Apex code we implemented:

                                       
   public with sharing class GA4Integration {
   @AuraEnabled
   public static void sendEvent(String eventName, Map eventParams) {
      String measurementId = 'G-XXXXXXX';
      String apiSecret = 'API_SECRET';
      String endpoint = 'https://www.google-analytics.com/mp/collect?
      measurement_id=' + measurementId + '&api_secret=' + apiSecret;
 
      Map payload = new Map();
        payload.put('client_id', '555'); // Static client ID for demo purposes
        payload.put('events', new List>{
         new Map{
               'name' => eventName,
                'params' => eventParams
         }
      });
 
      Http http = new Http();
      HttpRequest request = new HttpRequest();
        request.setEndpoint(endpoint);
        request.setMethod('POST');
        request.setHeader('Content-Type', 'application/json');
        request.setBody(JSON.serialize(payload));
 
      try {

          HttpResponse response = http.send(request);
         if (response.getStatusCode() != 200) {
                System.debug('Error sending event: ' + response.getBody());
         }
      } catch (Exception e) {
            System.debug('Exception: ' + e.getMessage());
      }
   }
}

Possible Scenarios and Solutions

  • Tracking Offline Conversions

    • Scenario: A Lead converts offline (e.g., via phone).
    • Solution: Use Apex to send a "purchase" event to GA4 when the Lead’s status changes to "Converted."
  • Error Handling

    • Scenario: The GA4 API is down.
    • Solution: Implement retry logic and log errors for review.
  • Client ID Matching

    • Scenario: Matching website visitors with Salesforce records.
    • Solution: Use a custom field in Salesforce to store and sync the GA4 client ID.
  • Custom Events

    • Scenario: Track custom business-specific events (e.g., booking an appointment).
    • Solution: Use the eventParmas map to define custom parameters.

Working Functionality

Sample Response in Salesforce Debug Logs: 

   GA4 Response: {
    "statusCode": 200,
    "status": "OK",
    "body": "{"event":"purchase","status":"success",
    "message":"Event processed successfully"}"
}

For any queries please reach out to support@astreait.com