Attribution Tools & Platforms

┌─────────────────────────────────────────────────────────────────┐
│                  ATTRIBUTION TOOL CATEGORIES                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  WEB ANALYTICS (Free - Mid-tier)                               │
│  ├── Google Analytics 4                                        │
│  ├── Adobe Analytics                                           │
│  └── Mixpanel / Amplitude                                      │
│                                                                 │
│  MOBILE ATTRIBUTION (Mid-tier - Enterprise)                    │
│  ├── AppsFlyer                                                 │
│  ├── Adjust                                                    │
│  ├── Branch                                                    │
│  └── Singular                                                  │
│                                                                 │
│  MULTI-TOUCH ATTRIBUTION (Enterprise)                          │
│  ├── Rockerbox                                                 │
│  ├── Northbeam                                                 │
│  ├── Triple Whale                                              │
│  └── Measured                                                  │
│                                                                 │
│  CUSTOMER DATA PLATFORMS (Enterprise)                          │
│  ├── Segment                                                   │
│  ├── mParticle                                                 │
│  └── Rudderstack                                               │
│                                                                 │
│  CUSTOM SOLUTIONS                                               │
│  └── Build your own (PostgreSQL/BigQuery + custom code)        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

// GA4 Attribution Configuration
// Admin → Attribution Settings

const ga4Attribution = {
  // Available models
  models: [
    'data_driven',      // ML-based (default, requires 400+ conversions)
    'last_click',       // 100% to final click
    'first_click',      // 100% to first click
    'linear',           // Equal distribution
    'position_based',   // 40/20/40
    'time_decay'        // Recency-weighted
  ],

  // Lookback windows
  lookbackWindows: {
    acquisition: 30,    // For new user conversions
    other: 90           // For returning user conversions
  },

  // Reporting dimensions
  dimensions: [
    'sessionDefaultChannelGroup',
    'sessionSource',
    'sessionMedium',
    'sessionCampaignName',
    'firstUserDefaultChannelGroup',
    'firstUserSource',
    'firstUserMedium'
  ]
};

// GA4 Data API - Attribution Report
async function getGA4AttributionReport(propertyId, startDate, endDate) {
  const { BetaAnalyticsDataClient } = require('@google-analytics/data');
  const client = new BetaAnalyticsDataClient();

  const [response] = await client.runReport({
    property: `properties/${propertyId}`,
    dateRanges: [{ startDate, endDate }],
    dimensions: [
      { name: 'sessionDefaultChannelGroup' },
      { name: 'sessionCampaignName' }
    ],
    metrics: [
      { name: 'conversions' },
      { name: 'totalRevenue' },
      { name: 'sessions' },
      { name: 'engagedSessions' }
    ],
    orderBys: [
      { metric: { metricName: 'conversions' }, desc: true }
    ]
  });

  return response.rows.map(row => ({
    channel: row.dimensionValues[0].value,
    campaign: row.dimensionValues[1].value,
    conversions: parseFloat(row.metricValues[0].value),
    revenue: parseFloat(row.metricValues[1].value),
    sessions: parseInt(row.metricValues[2].value),
    engagedSessions: parseInt(row.metricValues[3].value)
  }));
}

-- BigQuery: Custom Attribution Analysis
-- Export GA4 data to BigQuery for advanced attribution

-- Get user journeys with all touchpoints
WITH user_journeys AS (
  SELECT
    user_pseudo_id,
    event_timestamp,
    traffic_source.source,
    traffic_source.medium,
    traffic_source.name as campaign,
    collected_traffic_source.gclid,
    event_name,
    CASE
      WHEN event_name = 'purchase' THEN
        (SELECT value.double_value FROM UNNEST(event_params) WHERE key = 'value')
      ELSE 0
    END as conversion_value
  FROM `project.analytics_123456789.events_*`
  WHERE _TABLE_SUFFIX BETWEEN '20260101' AND '20260131'
),

-- Build conversion paths
conversion_paths AS (
  SELECT
    user_pseudo_id,
    ARRAY_AGG(
      STRUCT(
        source,
        medium,
        campaign,
        event_timestamp
      )
      ORDER BY event_timestamp
    ) as touchpoints,
    MAX(CASE WHEN event_name = 'purchase' THEN conversion_value END) as value
  FROM user_journeys
  GROUP BY user_pseudo_id
  HAVING MAX(CASE WHEN event_name = 'purchase' THEN 1 ELSE 0 END) = 1
),

-- Apply position-based attribution
attributed AS (
  SELECT
    user_pseudo_id,
    touchpoint.source,
    touchpoint.medium,
    touchpoint.campaign,
    CASE
      WHEN touchpoint_index = 0 THEN 0.4
      WHEN touchpoint_index = ARRAY_LENGTH(touchpoints) - 1 THEN 0.4
      ELSE 0.2 / (ARRAY_LENGTH(touchpoints) - 2)
    END as credit,
    value
  FROM conversion_paths,
  UNNEST(touchpoints) as touchpoint WITH OFFSET as touchpoint_index
)

-- Aggregate by channel
SELECT
  source,
  medium,
  campaign,
  SUM(credit) as attributed_conversions,
  SUM(credit * value) as attributed_revenue
FROM attributed
GROUP BY source, medium, campaign
ORDER BY attributed_revenue DESC;

// AppsFlyer Web SDK
<script>
  !function(t,e,n,s,a,c,i,o,p){
    t.AppsFlyerSdkObject=a,t.AF=t.AF||function(){
      (t.AF.q=t.AF.q||[]).push([Date.now()].concat(Array.prototype.slice.call(arguments)))
    },
    t.AF.id=t.AF.id||i,t.AF.plugins={},o=e.createElement(n),p=e.getElementsByTagName(n)[0],
    o.async=1,o.src="https://websdk.appsflyer.com?"+(c.length>0?"st="+c.split(",").sort().join(",")+"&":"")+(i.length>0?"af_id="+i:""),
    p.parentNode.insertBefore(o,p)
  }(window,document,"script",0,"AF","pba",{pba: {webAppId: "WEB_APP_ID"}})
</script>

<script>
  // Initialize with configuration
  AF('pba', 'init', {
    webAppId: 'YOUR_WEB_APP_ID',
    measurementStatus: true,
    afUserId: 'USER_ID' // Optional: your user ID
  });

  // Track page view
  AF('pba', 'pageView');

  // Track custom event
  AF('pba', 'event', {
    eventType: 'EVENT',
    eventName: 'purchase',
    eventRevenue: 99.99,
    eventRevenueCurrency: 'USD'
  });
</script>

// AppsFlyer Pull API
async function getAppsFlyerData(appId: string, apiToken: string) {
  const response = await fetch(
    `https://hq.appsflyer.com/export/${appId}/installs_report/v5?` +
    `api_token=${apiToken}&` +
    `from=2026-01-01&to=2026-01-31&` +
    `timezone=UTC`,
    { method: 'GET' }
  );

  const csv = await response.text();
  return parseCSV(csv);
}

// AppsFlyer Push API (Postback)
// Configure in AppsFlyer dashboard to receive real-time data
interface AppsFlyerPostback {
  appsflyer_id: string;
  customer_user_id: string;
  media_source: string;
  campaign: string;
  campaign_id: string;
  adset: string;
  ad: string;
  event_name: string;
  event_value: string;
  event_revenue: number;
  event_revenue_currency: string;
  install_time: string;
  event_time: string;
  platform: string;
  attributed_touch_type: string;
  attributed_touch_time: string;
}

// Segment Analytics.js
analytics.identify('user_123', {
  email: 'user@example.com',
  name: 'John Doe',
  plan: 'premium'
});

// Track page with attribution context
analytics.page('Home', {
  path: '/',
  referrer: document.referrer,
  search: window.location.search,
  title: document.title,
  url: window.location.href,
  // Custom attribution data
  utm_source: getUTM('utm_source'),
  utm_medium: getUTM('utm_medium'),
  utm_campaign: getUTM('utm_campaign'),
  gclid: getParam('gclid'),
  fbclid: getParam('fbclid')
});

// Track conversion
analytics.track('Order Completed', {
  order_id: 'ORDER_123',
  revenue: 99.99,
  currency: 'USD',
  products: [
    { product_id: 'SKU_123', name: 'Product', price: 99.99, quantity: 1 }
  ]
});

// Segment Personas (Identity Resolution)
// Configure in Segment workspace

const personasConfig = {
  // Identity resolution rules
  identityResolution: {
    // Merge profiles based on these identifiers
    identifiers: ['user_id', 'email', 'phone'],

    // Priority for conflicts
    priority: ['user_id', 'email', 'phone', 'anonymous_id'],

    // Cross-device linking
    crossDevice: true
  },

  // Computed traits for attribution
  computedTraits: {
    first_touch_channel: {
      type: 'first',
      property: 'context.campaign.source',
      eventType: 'track'
    },
    last_touch_channel: {
      type: 'last',
      property: 'context.campaign.source',
      eventType: 'track'
    },
    touchpoint_count: {
      type: 'count',
      eventType: 'page'
    }
  }
};

// Rockerbox Attribution Model
interface RockerboxAttribution {
  // Supported models
  models: [
    'first_touch',
    'last_touch',
    'even_weight',      // Linear
    'position_based',
    'time_decay',
    'data_driven',      // ML-based
    'custom'            // Define your own
  ];

  // Unique features
  features: {
    deduplication: true,        // Cross-platform dedup
    viewThrough: true,          // Impression attribution
    incrementality: true,       // Lift measurement
    mmm: true,                  // Marketing mix modeling
    offlineConversions: true,   // CRM integration
    cohortAnalysis: true        // LTV by acquisition source
  };

  // Data sources
  integrations: [
    'Google Ads',
    'Meta Ads',
    'TikTok Ads',
    'Pinterest Ads',
    'Snapchat Ads',
    'Connected TV',
    'Direct Mail',
    'Podcasts',
    'Influencer',
    'Affiliate'
  ];
}

// Rockerbox Conversion API
async function sendConversionToRockerbox(conversion: any) {
  const response = await fetch('https://api.rockerbox.com/v2/conversions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.ROCKERBOX_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      conversion_id: conversion.id,
      timestamp: conversion.timestamp,
      revenue: conversion.value,
      currency: 'USD',
      customer_id: conversion.userId,

      // Attribution identifiers
      identifiers: {
        email_hash: hashSHA256(conversion.email),
        phone_hash: hashSHA256(conversion.phone),
        rockerbox_id: conversion.rockerboxId,
        ip_address: conversion.ip
      },

      // Product data
      products: conversion.items.map(item => ({
        sku: item.sku,
        name: item.name,
        quantity: item.quantity,
        price: item.price
      }))
    })
  });

  return response.json();
}

<!-- Triple Whale Pixel -->
<script>
  !function(e,t,n,c,o,a,f){
    e.TriplePixelData=o,e[o]=e[o]||function(){
      (e[o].q=e[o].q||[]).push(arguments)
    },
    a=t.createElement(n),f=t.getElementsByTagName(n)[0],
    a.async=1,a.src=c,f.parentNode.insertBefore(a,f)
  }(window,document,"script","https://api.triplewhale.com/v1/pixel.js","TriplePixel");

  TriplePixel("init", "YOUR_PIXEL_ID");
</script>

// Triple Whale Attribution Capabilities
const tripleWhaleFeatures = {
  // First-party pixel
  pixel: {
    serverSide: true,
    cookieless: true,
    crossDomain: true
  },

  // Attribution models
  attribution: {
    models: ['first_click', 'last_click', 'linear', 'triple_attribution'],
    tripleAttribution: {
      // Proprietary model combining:
      // - First-party pixel data
      // - Post-purchase surveys
      // - Platform-reported data
      // - Statistical modeling
    }
  },

  // Integrations
  platforms: [
    'Shopify',
    'Meta Ads',
    'Google Ads',
    'TikTok Ads',
    'Klaviyo',
    'Recharge',
    'Gorgias'
  ],

  // Analytics
  analytics: {
    cohortLTV: true,
    customerJourneys: true,
    creativePerfomance: true,
    blendedROAS: true
  }
};

// Custom Attribution System Architecture
const customAttribution = {
  // Data collection layer
  collection: {
    client: 'Custom JavaScript SDK',
    server: 'Next.js API Routes',
    mobile: 'React Native SDK'
  },

  // Storage
  database: {
    transactional: 'PostgreSQL (Supabase)',
    analytics: 'BigQuery / ClickHouse',
    cache: 'Redis'
  },

  // Processing
  attribution: {
    realtime: 'Edge Functions',
    batch: 'Scheduled Jobs',
    ml: 'Python (scikit-learn)'
  },

  // Visualization
  reporting: {
    dashboards: 'Metabase / Looker',
    apis: 'REST / GraphQL',
    exports: 'CSV / Parquet'
  }
};

Custom Solution (1M monthly events):
├── Supabase Pro: $25/month
├── BigQuery: ~$50/month
├── Vercel: $20/month
├── Development: 80-160 hours initial
└── Total: ~$100/month + dev time

GA4 Free:
├── Cost: $0
├── Limitations: 14-month retention, sampling
└── Best for: < $1M annual revenue

AppsFlyer:
├── Cost: $0.05-0.10 per install
├── Minimum: ~$500/month
└── Best for: Mobile-first apps

Rockerbox:
├── Cost: $2,000-10,000/month
├── Enterprise features
└── Best for: $10M+ annual revenue

Triple Whale:
├── Cost: $100-2,000/month
├── Shopify-focused
└── Best for: D2C e-commerce

┌─────────────────────────────────────────────────────────────┐
│                  ATTRIBUTION TOOL SELECTOR                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  What's your primary platform?                              │
│  ├── Mobile App → AppsFlyer / Adjust / Branch              │
│  ├── Shopify → Triple Whale / Northbeam                    │
│  ├── Web + Mobile → Branch / Segment                       │
│  └── Web only ↓                                            │
│                                                             │
│  Annual marketing spend?                                    │
│  ├── < $100K → GA4 (free)                                  │
│  ├── $100K - $1M → GA4 + custom                            │
│  ├── $1M - $10M → Rockerbox / Northbeam                    │
│  └── > $10M → Enterprise (Adobe / custom)                  │
│                                                             │
│  Technical resources?                                       │
│  ├── No dev team → Managed solutions (Triple Whale)        │
│  ├── Some dev → GA4 + light custom                         │
│  └── Strong dev → Custom solution                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

## Data Collection
□ Supports all your traffic sources
□ Click ID capture (gclid, fbclid, etc.)
□ Server-side tracking option
□ Cross-device identity resolution
□ Privacy compliance (GDPR, CCPA)

## Attribution Models
□ Multiple models available
□ Data-driven attribution option
□ Customizable lookback windows
□ View-through attribution
□ Offline conversion support

## Integration
□ Connects to your ad platforms
□ CRM/CDP integration
□ Warehouse export (BigQuery, etc.)
□ API access for custom analysis
□ Real-time data availability

## Reporting
□ Cross-channel comparison
□ Campaign-level drill-down
□ Custom date ranges
□ Export capabilities
□ Automated reporting

## Support & Reliability
□ Uptime SLA
□ Technical support quality
□ Documentation quality
□ Implementation assistance
□ Training resources

Primary: GA4 (free)
Supplement: Custom touchpoint tracking
Budget: $0-100/month
Focus: Get data flowing, learn basics

Primary: GA4 + BigQuery
Secondary: Triple Whale or Rockerbox
Budget: $200-2,000/month
Focus: Cross-channel optimization

Primary: Enterprise MTA (Rockerbox, Measured)
Secondary: CDP (Segment, mParticle)
Custom: Data warehouse + ML models
Budget: $5,000-20,000/month
Focus: Incrementality, MMM, precision