Marketing Attribution Complete Guide 2026

Without Attribution:
├── Overspend on last-click channels (branded search, retargeting)
├── Underfund awareness channels (content, social, display)
├── Make budget decisions based on gut feeling
├── Can't prove marketing ROI to leadership
└── Miss optimization opportunities

With Attribution:
├── Understand true channel contribution
├── Optimize budget allocation scientifically
├── Identify high-value customer journeys
├── Prove marketing ROI with data
└── Scale what works, cut what doesn't

Customer Journey:
Blog Post → Social Ad → Email → Google Ad → Purchase

Credit Distribution:
Blog Post: 100%
Social Ad: 0%
Email: 0%
Google Ad: 0%

Customer Journey:
Blog Post → Social Ad → Email → Google Ad → Purchase

Credit Distribution:
Blog Post: 0%
Social Ad: 0%
Email: 0%
Google Ad: 100%

Customer Journey:
Blog Post → Social Ad → Email → Direct → Purchase

Credit Distribution:
Email: 100% (Direct ignored)

Customer Journey:
Blog Post → Social Ad → Email → Google Ad → Purchase

Credit Distribution (4 touchpoints):
Blog Post: 25%
Social Ad: 25%
Email: 25%
Google Ad: 25%

Customer Journey (7-day half-life):
Blog Post (Day 1) → Social Ad (Day 3) → Email (Day 5) → Google Ad (Day 7) → Purchase

Credit Distribution:
Blog Post: 10%
Social Ad: 15%
Email: 25%
Google Ad: 50%

Customer Journey:
Blog Post → Social Ad → Email → Webinar → Google Ad → Purchase

Credit Distribution:
Blog Post: 40% (First)
Social Ad: 6.67%
Email: 6.67%
Webinar: 6.67%
Google Ad: 40% (Last)

B2B Journey:
Blog Post → Whitepaper → Demo Request → Sales Call → Proposal → Close

Credit Distribution:
Blog Post: 30% (First Touch)
Whitepaper: 5%
Demo Request: 30% (Lead Created)
Sales Call: 30% (Opportunity Created)
Proposal: 5%

# Conceptual DDA Implementation
from sklearn.ensemble import GradientBoostingClassifier
import numpy as np

class DataDrivenAttribution:
    """
    ML-based attribution using Shapley values
    """
    def __init__(self):
        self.model = GradientBoostingClassifier()
        self.channel_importance = {}

    def prepare_journey_features(self, journeys):
        """
        Convert customer journeys to feature matrix
        """
        channels = ['organic', 'paid_search', 'social', 'email', 'display', 'direct']
        features = []

        for journey in journeys:
            # Binary presence of each channel
            channel_presence = [1 if ch in journey['touchpoints'] else 0 for ch in channels]
            # Position features
            first_touch = journey['touchpoints'][0] if journey['touchpoints'] else None
            last_touch = journey['touchpoints'][-1] if journey['touchpoints'] else None
            # Interaction features
            journey_length = len(journey['touchpoints'])

            features.append(channel_presence + [journey_length])

        return np.array(features)

    def calculate_shapley_values(self, journey):
        """
        Calculate Shapley values for attribution credit
        """
        touchpoints = journey['touchpoints']
        n = len(touchpoints)
        shapley_values = {}

        for channel in set(touchpoints):
            marginal_contributions = []

            # Calculate marginal contribution across all permutations
            for subset_size in range(n):
                # Probability of conversion with channel
                with_channel = self.model.predict_proba(
                    self._journey_to_features(touchpoints)
                )[0][1]

                # Probability without channel
                without = [t for t in touchpoints if t != channel]
                without_channel = self.model.predict_proba(
                    self._journey_to_features(without)
                )[0][1] if without else 0

                marginal_contributions.append(with_channel - without_channel)

            shapley_values[channel] = np.mean(marginal_contributions)

        # Normalize to sum to 1
        total = sum(shapley_values.values())
        return {k: v/total for k, v in shapley_values.items()}

┌─────────────────────────────────────────────────────────────┐
│                   ATTRIBUTION MODEL SELECTOR                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Monthly Conversions < 500?                                 │
│  ├── YES → Use Position-Based or Linear                    │
│  └── NO ↓                                                  │
│                                                             │
│  Sales Cycle > 30 days?                                     │
│  ├── YES → Use W-Shaped (B2B) or Time Decay               │
│  └── NO ↓                                                  │
│                                                             │
│  Monthly Conversions > 1000?                                │
│  ├── YES → Use Data-Driven Attribution                     │
│  └── NO → Use Position-Based                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Recommended: Data-Driven or Time Decay
Lookback: 7-30 days
Key Channels: Paid Search, Shopping, Social, Email
Focus: Revenue attribution, ROAS optimization

Recommended: W-Shaped or Position-Based
Lookback: 60-90 days
Key Channels: Content, Paid, Events, Sales
Focus: Pipeline attribution, CAC optimization

Recommended: Position-Based
Lookback: 30-60 days
Key Channels: Paid Search, SEO, Social, Referral
Focus: Cost per lead by channel, lead quality

Recommended: Custom W-Shaped with account-level
Lookback: 180+ days
Key Channels: ABM, Events, Content, Outbound
Focus: Account attribution, influenced pipeline

// GA4 Conversion Event Hierarchy
const conversionEvents = {
  macro: [
    { name: 'purchase', value: 'transaction_value' },
    { name: 'generate_lead', value: 50 },  // Estimated lead value
    { name: 'sign_up', value: 25 }
  ],
  micro: [
    { name: 'add_to_cart', value: 5 },
    { name: 'begin_checkout', value: 10 },
    { name: 'view_item', value: 1 },
    { name: 'download', value: 15 }
  ]
};

// Track with proper event structure
function trackConversion(eventName, eventParams) {
  gtag('event', eventName, {
    ...eventParams,
    send_to: 'G-XXXXXXXXXX',
    // Include user ID for cross-device
    user_id: getUserId(),
    // Include session data
    session_id: getSessionId(),
    // Timestamp for time decay
    event_timestamp: Date.now()
  });
}

// Unified tracking across channels
class AttributionTracker {
  constructor(config) {
    this.config = config;
    this.touchpoints = this.loadTouchpoints();
  }

  // Capture touchpoint on every page
  captureTouchpoint() {
    const touchpoint = {
      timestamp: Date.now(),
      channel: this.identifyChannel(),
      source: this.getUTMParam('utm_source'),
      medium: this.getUTMParam('utm_medium'),
      campaign: this.getUTMParam('utm_campaign'),
      content: this.getUTMParam('utm_content'),
      term: this.getUTMParam('utm_term'),
      referrer: document.referrer,
      landing_page: window.location.pathname,
      gclid: this.getParam('gclid'),
      fbclid: this.getParam('fbclid'),
      msclkid: this.getParam('msclkid'),
      session_id: this.getSessionId(),
      user_id: this.getUserId()
    };

    this.touchpoints.push(touchpoint);
    this.saveTouchpoints();
    this.sendToServer(touchpoint);
  }

  identifyChannel() {
    const params = new URLSearchParams(window.location.search);
    const referrer = document.referrer;

    // Paid channels (highest priority)
    if (params.get('gclid')) return 'google_ads';
    if (params.get('fbclid')) return 'meta_ads';
    if (params.get('msclkid')) return 'microsoft_ads';
    if (params.get('ttclid')) return 'tiktok_ads';
    if (params.get('li_fat_id')) return 'linkedin_ads';

    // UTM-based identification
    const medium = params.get('utm_medium')?.toLowerCase();
    if (medium) {
      if (['cpc', 'ppc', 'paid'].includes(medium)) return 'paid_search';
      if (['social', 'social-paid'].includes(medium)) return 'paid_social';
      if (medium === 'email') return 'email';
      if (medium === 'affiliate') return 'affiliate';
      if (medium === 'referral') return 'referral';
      if (medium === 'display') return 'display';
    }

    // Referrer-based identification
    if (referrer) {
      const refDomain = new URL(referrer).hostname;

      // Search engines
      if (/google\.|bing\.|yahoo\.|duckduckgo\./.test(refDomain)) {
        return 'organic_search';
      }

      // Social networks
      if (/facebook\.|instagram\.|twitter\.|linkedin\.|tiktok\./.test(refDomain)) {
        return 'organic_social';
      }

      // External referral
      if (refDomain !== window.location.hostname) {
        return 'referral';
      }
    }

    return 'direct';
  }

  // Send touchpoint to server for attribution
  async sendToServer(touchpoint) {
    await fetch('/api/attribution/touchpoint', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        ...touchpoint,
        client_id: this.getClientId(),
        page_title: document.title,
        viewport: {
          width: window.innerWidth,
          height: window.innerHeight
        }
      })
    });
  }

  // Get all touchpoints for current user
  getJourney() {
    return this.touchpoints.sort((a, b) => a.timestamp - b.timestamp);
  }

  // Calculate attribution using specified model
  calculateAttribution(model = 'position_based') {
    const journey = this.getJourney();

    switch (model) {
      case 'first_touch':
        return this.firstTouchAttribution(journey);
      case 'last_touch':
        return this.lastTouchAttribution(journey);
      case 'linear':
        return this.linearAttribution(journey);
      case 'time_decay':
        return this.timeDecayAttribution(journey);
      case 'position_based':
        return this.positionBasedAttribution(journey);
      default:
        return this.positionBasedAttribution(journey);
    }
  }

  positionBasedAttribution(journey) {
    if (journey.length === 0) return {};
    if (journey.length === 1) return { [journey[0].channel]: 1.0 };

    const attribution = {};
    const firstTouch = journey[0];
    const lastTouch = journey[journey.length - 1];
    const middleTouches = journey.slice(1, -1);

    // 40% to first
    attribution[firstTouch.channel] = (attribution[firstTouch.channel] || 0) + 0.4;

    // 40% to last
    attribution[lastTouch.channel] = (attribution[lastTouch.channel] || 0) + 0.4;

    // 20% split among middle
    if (middleTouches.length > 0) {
      const middleCredit = 0.2 / middleTouches.length;
      middleTouches.forEach(touch => {
        attribution[touch.channel] = (attribution[touch.channel] || 0) + middleCredit;
      });
    } else {
      // No middle touches - split 50/50
      attribution[firstTouch.channel] = 0.5;
      attribution[lastTouch.channel] = (attribution[lastTouch.channel] || 0) + 0.1;
    }

    return attribution;
  }

  timeDecayAttribution(journey, halfLife = 7) {
    if (journey.length === 0) return {};

    const now = Date.now();
    const dayMs = 24 * 60 * 60 * 1000;
    const attribution = {};
    let totalWeight = 0;

    journey.forEach(touch => {
      const daysAgo = (now - touch.timestamp) / dayMs;
      const weight = Math.pow(0.5, daysAgo / halfLife);
      attribution[touch.channel] = (attribution[touch.channel] || 0) + weight;
      totalWeight += weight;
    });

    // Normalize
    Object.keys(attribution).forEach(channel => {
      attribution[channel] /= totalWeight;
    });

    return attribution;
  }
}

// Initialize tracker
const attributionTracker = new AttributionTracker({
  cookieDomain: '.yourdomain.com',
  lookbackDays: 30,
  sessionTimeout: 30 * 60 * 1000 // 30 minutes
});

// Track on page load
attributionTracker.captureTouchpoint();

// Server-side attribution service (Node.js/TypeScript)
import { createClient } from '@supabase/supabase-js';

interface Touchpoint {
  id: string;
  user_id: string;
  client_id: string;
  timestamp: number;
  channel: string;
  source: string;
  medium: string;
  campaign: string;
  landing_page: string;
  referrer: string;
}

interface Conversion {
  id: string;
  user_id: string;
  timestamp: number;
  event_name: string;
  value: number;
  currency: string;
}

interface AttributionResult {
  conversion_id: string;
  channel: string;
  credit: number;
  value: number;
  model: string;
}

class AttributionService {
  private supabase;
  private lookbackDays: number;

  constructor(supabaseUrl: string, supabaseKey: string) {
    this.supabase = createClient(supabaseUrl, supabaseKey);
    this.lookbackDays = 30;
  }

  async processConversion(conversion: Conversion): Promise<AttributionResult[]> {
    // Get user's touchpoints within lookback window
    const lookbackStart = conversion.timestamp - (this.lookbackDays * 24 * 60 * 60 * 1000);

    const { data: touchpoints } = await this.supabase
      .from('touchpoints')
      .select('*')
      .eq('user_id', conversion.user_id)
      .gte('timestamp', lookbackStart)
      .lte('timestamp', conversion.timestamp)
      .order('timestamp', { ascending: true });

    if (!touchpoints || touchpoints.length === 0) {
      // No touchpoints found - attribute to direct
      return [{
        conversion_id: conversion.id,
        channel: 'direct',
        credit: 1.0,
        value: conversion.value,
        model: 'position_based'
      }];
    }

    // Calculate attribution
    const attribution = this.calculatePositionBased(touchpoints);

    // Create attribution records
    const results: AttributionResult[] = [];
    for (const [channel, credit] of Object.entries(attribution)) {
      results.push({
        conversion_id: conversion.id,
        channel,
        credit,
        value: conversion.value * credit,
        model: 'position_based'
      });
    }

    // Store attribution results
    await this.supabase.from('attribution_results').insert(results);

    return results;
  }

  calculatePositionBased(touchpoints: Touchpoint[]): Record<string, number> {
    const attribution: Record<string, number> = {};

    if (touchpoints.length === 1) {
      attribution[touchpoints[0].channel] = 1.0;
      return attribution;
    }

    const first = touchpoints[0];
    const last = touchpoints[touchpoints.length - 1];
    const middle = touchpoints.slice(1, -1);

    // 40% first, 40% last
    attribution[first.channel] = 0.4;
    attribution[last.channel] = (attribution[last.channel] || 0) + 0.4;

    // 20% split among middle
    if (middle.length > 0) {
      const middleCredit = 0.2 / middle.length;
      middle.forEach(t => {
        attribution[t.channel] = (attribution[t.channel] || 0) + middleCredit;
      });
    }

    return attribution;
  }

  // Generate attribution report
  async getAttributionReport(
    startDate: Date,
    endDate: Date,
    model: string = 'position_based'
  ) {
    const { data } = await this.supabase
      .from('attribution_results')
      .select(`
        channel,
        credit,
        value,
        conversions!inner(event_name, timestamp)
      `)
      .eq('model', model)
      .gte('conversions.timestamp', startDate.toISOString())
      .lte('conversions.timestamp', endDate.toISOString());

    // Aggregate by channel
    const channelStats: Record<string, {
      attributed_conversions: number;
      attributed_value: number;
      touchpoints: number;
    }> = {};

    data?.forEach(row => {
      if (!channelStats[row.channel]) {
        channelStats[row.channel] = {
          attributed_conversions: 0,
          attributed_value: 0,
          touchpoints: 0
        };
      }
      channelStats[row.channel].attributed_conversions += row.credit;
      channelStats[row.channel].attributed_value += row.value;
      channelStats[row.channel].touchpoints += 1;
    });

    return channelStats;
  }
}

export const attributionService = new AttributionService(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_KEY!
);

// GA4 Attribution Settings
// Admin → Attribution Settings

const ga4AttributionConfig = {
  // Reporting attribution model
  reportingModel: 'data-driven', // or 'last-click', 'first-click', etc.

  // Lookback windows
  acquisitionConversionWindow: 30, // days
  otherConversionWindow: 90, // days

  // Engaged-view conversions (YouTube)
  engagedViewWindow: 3 // days
};

// Enhanced conversions for better attribution
gtag('config', 'G-XXXXXXXXXX', {
  // Enable enhanced conversions
  'enhanced_conversions': true,

  // User ID for cross-device
  'user_id': 'USER_ID',

  // Allow Google signals
  'allow_google_signals': true,

  // Allow ad personalization
  'allow_ad_personalization_signals': true
});

// Send user data for enhanced matching
gtag('set', 'user_data', {
  'email': hashEmail(user.email),
  'phone_number': hashPhone(user.phone),
  'address': {
    'first_name': user.firstName,
    'last_name': user.lastName,
    'street': user.street,
    'city': user.city,
    'region': user.state,
    'postal_code': user.zip,
    'country': user.country
  }
});

// Google Ads conversion with attribution data
gtag('event', 'conversion', {
  'send_to': 'AW-CONVERSION_ID/CONVERSION_LABEL',
  'value': 100.00,
  'currency': 'USD',
  'transaction_id': 'ORDER_12345',

  // Enhanced conversions data
  'user_data': {
    'email': hashEmail(user.email),
    'phone_number': hashPhone(user.phone)
  }
});

// Consent mode for privacy compliance
gtag('consent', 'default', {
  'ad_storage': 'denied',
  'analytics_storage': 'denied',
  'ad_user_data': 'denied',
  'ad_personalization': 'denied'
});

// Update on consent
function updateConsent(hasConsent) {
  gtag('consent', 'update', {
    'ad_storage': hasConsent ? 'granted' : 'denied',
    'analytics_storage': hasConsent ? 'granted' : 'denied',
    'ad_user_data': hasConsent ? 'granted' : 'denied',
    'ad_personalization': hasConsent ? 'granted' : 'denied'
  });
}

// Meta Pixel with attribution parameters
fbq('init', 'PIXEL_ID', {
  'external_id': 'USER_ID' // For cross-device matching
});

// Track conversion with attribution data
fbq('track', 'Purchase', {
  value: 100.00,
  currency: 'USD',
  content_ids: ['SKU123'],
  content_type: 'product',

  // Include click ID for attribution
  fbc: getFBClickId(),
  fbp: getFBBrowserId()
}, {
  eventID: 'unique_event_id' // For deduplication with CAPI
});

// Server-side CAPI for better attribution
async function sendCAPIConversion(event) {
  const payload = {
    data: [{
      event_name: 'Purchase',
      event_time: Math.floor(Date.now() / 1000),
      event_id: event.eventId, // Match client-side
      event_source_url: event.url,
      action_source: 'website',
      user_data: {
        em: [hashSHA256(event.email)],
        ph: [hashSHA256(event.phone)],
        fbc: event.fbc,
        fbp: event.fbp,
        client_ip_address: event.ip,
        client_user_agent: event.userAgent
      },
      custom_data: {
        value: event.value,
        currency: 'USD',
        content_ids: event.productIds
      }
    }]
  };

  await fetch(
    `https://graph.facebook.com/v18.0/PIXEL_ID/events?access_token=${ACCESS_TOKEN}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload)
    }
  );
}

-- Attribution performance by channel (Supabase/PostgreSQL)
WITH channel_attribution AS (
  SELECT
    ar.channel,
    SUM(ar.credit) as attributed_conversions,
    SUM(ar.value) as attributed_revenue,
    COUNT(DISTINCT ar.conversion_id) as total_conversions
  FROM attribution_results ar
  JOIN conversions c ON ar.conversion_id = c.id
  WHERE c.timestamp >= NOW() - INTERVAL '30 days'
    AND ar.model = 'position_based'
  GROUP BY ar.channel
),
channel_spend AS (
  SELECT
    channel,
    SUM(spend) as total_spend
  FROM marketing_spend
  WHERE date >= CURRENT_DATE - INTERVAL '30 days'
  GROUP BY channel
)
SELECT
  ca.channel,
  ca.attributed_conversions,
  ca.attributed_revenue,
  cs.total_spend,
  ROUND(ca.attributed_revenue / NULLIF(cs.total_spend, 0), 2) as roas,
  ROUND(cs.total_spend / NULLIF(ca.attributed_conversions, 0), 2) as cpa
FROM channel_attribution ca
LEFT JOIN channel_spend cs ON ca.channel = cs.channel
ORDER BY ca.attributed_revenue DESC;

## Implementation
□ Define conversion events with values
□ Implement cross-device user identification
□ Set up UTM parameter standards
□ Configure lookback windows appropriately
□ Enable enhanced conversions on all platforms
□ Implement server-side tracking for accuracy

## Analysis
□ Compare multiple attribution models monthly
□ Analyze path length and time to conversion
□ Identify high-value customer journeys
□ Segment attribution by customer type
□ Review assisted vs last-click performance

## Optimization
□ Reallocate budget based on attributed performance
□ Test different lookback windows
□ Validate attribution with incrementality tests
□ Document attribution methodology for stakeholders
□ Review and update model quarterly

❌ Using only last-click attribution
❌ Ignoring cross-device behavior
❌ Short lookback windows for long sales cycles
❌ Not accounting for view-through conversions
❌ Comparing channels with different attribution models
❌ Making budget decisions on single model

✅ Use multi-touch attribution
✅ Implement user ID tracking
✅ Match lookback to sales cycle
✅ Include view-through for display/video
✅ Standardize models across channels
✅ Validate with incrementality testing