Google Analytics Integrations

Integration Inventory

Google Marketing Platform Integrations

Google Analytics integrates natively with the broader Google Marketing Platform ecosystem:

Google Ads

• Automatic conversion tracking and attribution
• Smart Bidding optimization using GA4 audiences
• Cross-platform campaign performance analysis
• Enhanced conversion tracking with first-party data

Google Search Console

• Organic search query data integration
• Landing page performance metrics
• Search appearance insights
• Core Web Vitals reporting

Google Tag Manager

• Centralized tag deployment and management
• Advanced event tracking configuration
• Server-side tagging capabilities
• Built-in GA4 template tags

Display & Video 360

• Campaign performance measurement
• Floodlight counter integration
• Audience sharing for programmatic campaigns
• Cross-device attribution reporting

Campaign Manager 360

• Ad serving metrics integration
• Conversion attribution analysis
• Creative performance tracking
• View-through conversion measurement

Search Ads 360

• Bidding strategy optimization
• Multi-engine campaign analytics
• Budget allocation insights
• Conversion funnel analysis

Data & Analytics Integrations

BigQuery Export (GA4 only)

• Raw event-level data streaming
• SQL-based custom analysis
• Machine learning model training
• Unlimited data retention

Looker Studio (formerly Data Studio)

• Drag-and-drop dashboard builder
• Real-time data visualization
• Custom report templates
• Cross-platform data blending

Firebase

• Mobile app analytics integration
• In-app event tracking
• User property synchronization
• Crash reporting correlation

Google Cloud Platform

• Cloud Functions for data processing
• Cloud Storage for data archival
• Vertex AI for predictive analytics
• Pub/Sub for real-time event streaming

Third-Party Platform Integrations

CRM & Marketing Automation

• Salesforce - Lead attribution and ROI tracking
• HubSpot - Marketing automation workflow triggers
• Marketo - Campaign performance analysis
• ActiveCampaign - Email engagement correlation

E-commerce Platforms

• Shopify - Enhanced e-commerce tracking
• WooCommerce - Product performance analytics
• Magento - Customer journey analysis
• BigCommerce - Transaction data integration

Customer Data Platforms

• Segment - Unified customer data collection
• mParticle - Cross-platform event orchestration
• Tealium - Tag management and audience activation
• Lytics - Customer segmentation and personalization

Data Warehouses

• Snowflake - Data consolidation and analysis
• Amazon Redshift - Enterprise data warehousing
• Azure Synapse - Microsoft cloud analytics
• Databricks - Lakehouse architecture integration

API Access & Custom Integrations

Google Analytics Reporting API v4 (Universal Analytics)

• Custom dashboard and report generation
• Automated data extraction workflows
• Multi-dimensional query capabilities
• Programmatic access to historical data

Google Analytics Data API (GA4)

• Real-time and historical data access
• Event-level reporting capabilities
• Funnel exploration queries
• Custom dimension and metric retrieval

Google Analytics Admin API

• Programmatic account configuration
• Property and data stream management
• User permission automation
• Conversion event setup

Measurement Protocol

• Server-side event tracking
• Offline conversion import
• IoT device data collection
• Call center interaction tracking

Licensing & Plan Requirements

GA4 Free vs. GA4 360

Universal Analytics (Sunset July 1, 2023)

• Standard: Free tier with basic features
• 360: Enterprise tier with SLA, unsampled data, and advanced features

Implementation Playbooks

Google Ads Integration Setup

Link Google Ads and Google Analytics for comprehensive campaign tracking:

Setup Steps

1. Sign in to Google Analytics
2. Navigate to Admin > Google Ads Linking
3. Click "Link" and select your Google Ads account
4. Enable auto-tagging in Google Ads
5. Configure link settings (import conversions, remarketing)
6. Save and verify data flow

Conversion Import Configuration

// GA4 event configuration for Google Ads conversion import
gtag('event', 'purchase', {
  transaction_id: 'T12345',
  value: 129.99,
  currency: 'USD',
  tax: 10.99,
  shipping: 5.99,
  items: [{
    item_id: 'SKU_12345',
    item_name: 'Product Name',
    item_category: 'Category',
    price: 113.01,
    quantity: 1
  }]
});

// Mark as primary conversion in GA4
// Admin > Events > Mark as conversion

Audience Sharing

1. In GA4, navigate to Admin > Audience Definitions
2. Create audience with desired criteria
3. Enable "Google Ads" as destination
4. Configure audience settings (membership duration, eligibility)
5. Wait 24-48 hours for audience to populate
6. Access audience in Google Ads for campaign targeting

QA Verification

• Verify auto-tagging is enabled (check for gclid parameter)
• Confirm conversions appear in Google Ads within 24 hours
• Validate conversion values match between platforms
• Check audience size updates in Google Ads interface
• Test remarketing campaigns with GA4 audiences

BigQuery Export Configuration

Stream GA4 event data to BigQuery for advanced analysis:

Initial Setup

1. Create Google Cloud Platform project
2. Enable BigQuery API
3. In GA4 Admin, navigate to BigQuery Linking
4. Select project and dataset location
5. Choose export frequency (Daily, Streaming, or both)
6. Configure export settings and save

Export Options

• Daily export: Batch processing once per day, no additional cost
• Streaming export: Real-time events, charged per GB ingested
• Include advertising identifiers: Optional PII considerations
• Export events: All events vs. specific events only

Sample BigQuery Queries

-- Daily active users by traffic source
SELECT
  traffic_source.source,
  traffic_source.medium,
  COUNT(DISTINCT user_pseudo_id) as daily_active_users
FROM
  `project.dataset.events_*`
WHERE
  _TABLE_SUFFIX = FORMAT_DATE('%Y%m%d', CURRENT_DATE())
GROUP BY
  traffic_source.source,
  traffic_source.medium
ORDER BY
  daily_active_users DESC;

-- E-commerce conversion funnel
WITH funnel_events AS (
  SELECT
    user_pseudo_id,
    COUNTIF(event_name = 'view_item') as viewed_items,
    COUNTIF(event_name = 'add_to_cart') as added_to_cart,
    COUNTIF(event_name = 'begin_checkout') as began_checkout,
    COUNTIF(event_name = 'purchase') as purchases
  FROM
    `project.dataset.events_*`
  WHERE
    _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY))
      AND FORMAT_DATE('%Y%m%d', CURRENT_DATE())
  GROUP BY
    user_pseudo_id
)
SELECT
  COUNTIF(viewed_items > 0) as step1_view_item,
  COUNTIF(added_to_cart > 0) as step2_add_to_cart,
  COUNTIF(began_checkout > 0) as step3_begin_checkout,
  COUNTIF(purchases > 0) as step4_purchase,
  ROUND(COUNTIF(added_to_cart > 0) / COUNTIF(viewed_items > 0) * 100, 2) as view_to_cart_rate,
  ROUND(COUNTIF(purchases > 0) / COUNTIF(began_checkout > 0) * 100, 2) as checkout_to_purchase_rate
FROM
  funnel_events;

-- Top landing pages with engagement metrics
SELECT
  REGEXP_EXTRACT((SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location'), r'([^?]+)') as landing_page,
  COUNT(DISTINCT user_pseudo_id) as users,
  AVG((SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'engagement_time_msec')) / 1000 as avg_engagement_seconds,
  COUNTIF(event_name = 'purchase') as conversions,
  ROUND(COUNTIF(event_name = 'purchase') / COUNT(DISTINCT user_pseudo_id) * 100, 2) as conversion_rate
FROM
  `project.dataset.events_*`
WHERE
  _TABLE_SUFFIX = FORMAT_DATE('%Y%m%d', CURRENT_DATE())
  AND event_name IN ('session_start', 'purchase')
GROUP BY
  landing_page
ORDER BY
  users DESC
LIMIT 25;

Cost Optimization

• Use table partitioning (_TABLE_SUFFIX) to limit scanned data
• Cluster tables by common query dimensions
• Set up scheduled queries for recurring reports
• Monitor BigQuery storage costs monthly
• Archive old data to Cloud Storage for cost savings

Salesforce Integration

Connect Google Analytics with Salesforce for closed-loop attribution:

Integration Methods

1. Native GA360 Connector (GA360 only)

   • Direct data sharing with Salesforce
   • Automated field mapping
   • Bi-directional data sync

2. Third-Party Tools

   • Salesforce Marketing Cloud integration
   • Pardot connector for B2B tracking
   • Custom ETL with Zapier or Integromat

3. Custom API Integration

   • GA Reporting API + Salesforce API
   • Server-side tracking with Measurement Protocol
   • Cloud Functions for automated data sync

Implementation Example

# Python script for syncing GA4 leads to Salesforce
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from simple_salesforce import Salesforce
import os
from datetime import datetime, timedelta

# Initialize clients
ga_client = BetaAnalyticsDataClient()
sf = Salesforce(
    username=os.getenv('SF_USERNAME'),
    password=os.getenv('SF_PASSWORD'),
    security_token=os.getenv('SF_TOKEN')
)

# Fetch conversions from GA4
def get_ga4_conversions(property_id, start_date, end_date):
    request = {
        "property": f"properties/{property_id}",
        "dimensions": [
            {"name": "sessionSource"},
            {"name": "sessionMedium"},
            {"name": "sessionCampaignName"}
        ],
        "metrics": [{"name": "conversions"}],
        "date_ranges": [{"start_date": start_date, "end_date": end_date}],
        "dimension_filter": {
            "filter": {
                "field_name": "eventName",
                "string_filter": {"value": "generate_lead"}
            }
        }
    }
    response = ga_client.run_report(request)
    return response

# Create leads in Salesforce
def create_sf_leads(conversions):
    for row in conversions.rows:
        lead_data = {
            'FirstName': 'GA4',
            'LastName': 'Lead',
            'Company': 'Unknown',
            'LeadSource': f"{row.dimension_values[0].value} / {row.dimension_values[1].value}",
            'Description': f"Campaign: {row.dimension_values[2].value}"
        }
        sf.Lead.create(lead_data)

# Execute sync
yesterday = (datetime.now() - timedelta(1)).strftime('%Y-%m-%d')
conversions = get_ga4_conversions('123456789', yesterday, yesterday)
create_sf_leads(conversions)

Data Activation

Audience Building & Activation

GA4 audiences enable sophisticated user segmentation and cross-platform activation:

Advanced Audience Configuration

// Predictive audience: Likely 7-day purchasers
// Conditions in GA4 UI:
// - Predicted purchase probability > 50%
// - Last active within 7 days
// - Device category = mobile

// Custom audience: High-value cart abandoners
// Conditions:
// - Event: add_to_cart (within last 30 days)
// - Event value > 100
// - NOT Event: purchase (within last 30 days)
// - Session count > 3

Multi-Platform Activation

1. Google Ads - Remarketing and similar audiences
2. Display & Video 360 - Programmatic display campaigns
3. Search Ads 360 - Search remarketing lists
4. YouTube - Video remarketing campaigns
5. Google Optimize - A/B testing and personalization
6. Firebase - Mobile app messaging and targeting

Conversion Modeling & Attribution

Enhanced Conversions Setup

Improve conversion tracking accuracy with first-party data:

// Enhanced conversion tracking with hashed user data
gtag('set', 'user_data', {
  "email": "user@example.com",
  "phone_number": "+15551234567",
  "address": {
    "first_name": "John",
    "last_name": "Doe",
    "street": "123 Main St",
    "city": "New York",
    "region": "NY",
    "postal_code": "10001",
    "country": "US"
  }
});

gtag('event', 'conversion', {
  'send_to': 'AW-123456789/AbCdEfGhIjKlMnOpQrSt',
  'value': 1.0,
  'currency': 'USD'
});

Data-Driven Attribution

• Enable in GA4 Admin > Attribution Settings
• Requires minimum data thresholds (400 conversions per conversion event)
• Distributes credit across touchpoints using machine learning
• Compare with other models (last-click, first-click, linear, time-decay)

Real-Time Personalization

Google Optimize Integration

<!-- Google Optimize anti-flicker snippet -->
<style>.async-hide { opacity: 0 !important} </style>
<script>
(function(a,s,y,n,c,h,i,d,e){s.className+=' '+y;h.start=1*new Date;
h.end=i=function(){s.className=s.className.replace(RegExp(' ?'+y),'')};
(a[n]=a[n]||[]).hide=h;setTimeout(function(){i();h.end=null},c);h.timeout=c;
})(window,document.documentElement,'async-hide','dataLayer',4000,
{'GTM-XXXXXX':true});
</script>

<!-- GA4 + Optimize integration -->
<script>
gtag('config', 'G-XXXXXXXXXX', {
  'optimize_id': 'OPT-XXXXXXX'
});
</script>

Personalization Use Cases

• Homepage hero variations based on traffic source
• Product recommendations based on browsing history
• Pricing display optimization by user segment
• Form field variations for conversion optimization

Refresh Cadences & Data Sync

Platform Sync Schedules

Team Ownership

• Marketing Team - Audience creation, campaign optimization, conversion tracking
• Analytics Team - Custom reporting, BigQuery analysis, data quality monitoring
• Engineering Team - API integrations, server-side tracking, technical implementation
• Data Team - Data warehouse integration, ETL pipeline maintenance, data governance

Compliance & Security

GDPR & Privacy Compliance

Consent Management

// Google Consent Mode v2 implementation
gtag('consent', 'default', {
  'ad_storage': 'denied',
  'ad_user_data': 'denied',
  'ad_personalization': 'denied',
  'analytics_storage': 'denied'
});

// Update consent based on user choice
function updateConsent(consent) {
  gtag('consent', 'update', {
    'ad_storage': consent.advertising ? 'granted' : 'denied',
    'ad_user_data': consent.advertising ? 'granted' : 'denied',
    'ad_personalization': consent.advertising ? 'granted' : 'denied',
    'analytics_storage': consent.analytics ? 'granted' : 'denied'
  });
}

Data Retention & Deletion

• Configure data retention periods in GA4 Admin (2-14 months)
• Enable user deletion requests via Measurement Protocol
• Implement right-to-be-forgotten workflows
• Document data processing agreements with Google

Data Processing Agreements

Required Documentation

• Google Ads Data Processing Terms
• Google Analytics Data Protection Terms
• BigQuery Data Processing Amendment
• Third-party integration vendor agreements

Security Assessments

• Annual vendor risk assessment for Google services
• Review data transfer mechanisms (Privacy Shield alternatives)
• Audit access controls and user permissions
• Document data flows in privacy impact assessments

Access Control Best Practices

User Permission Hierarchy

• Administrator - Full account access, user management
• Editor - Configuration changes, no user management
• Analyst - View and share reports, create audiences
• Viewer - Read-only access to reports

Service Account Management

# Create service account for API access
gcloud iam service-accounts create ga4-reporting \
    --display-name="GA4 Reporting Service Account"

# Grant Analytics Viewer role
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:ga4-reporting@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/analyticsviewer"

# Create and download key
gcloud iam service-accounts keys create ~/ga4-key.json \
    --iam-account=ga4-reporting@PROJECT_ID.iam.gserviceaccount.com

Monitoring & Alerting

Integration Health Checks

• Google Ads conversion import status monitoring
• BigQuery export job success/failure alerts
• API quota usage tracking and alerts
• Data quality anomaly detection

Compliance Monitoring

• Automated PII scanning in event parameters
• Consent mode implementation verification
• Data retention policy compliance checks
• Access log auditing and review

Advanced Integration Opportunities

Customer Data Platforms: GA4 integrates natively with BigQuery for warehouse-level analysis. For CDP connections, use Segment or mParticle to forward GA4 events to platforms like Braze, Iterable, or Customer.io for marketing automation. GA4's Measurement Protocol enables server-side event forwarding to any CDP that accepts HTTP webhooks.

Marketing Automation: Connect GA4 audiences to Google Ads for remarketing, or export audience lists via the GA4 Admin API to push segments to email platforms. Use the GA4 Data API for custom reporting dashboards that combine analytics data with CRM metrics.

Reverse ETL: Tools like Census, Hightouch, or Rudderstack can sync GA4 BigQuery exports back to operational tools (CRM, email, support), enabling analytics-driven workflows without custom code.