Maximieren Sie Ihr SEO-Potenzial mit Server Side Tracking: ein umfassender Leitfaden

// Beispiel: Event-Tracking in React Native App
import { trackServerSideEvent } from './tracking';

const handlePurchase = async (orderData) => {
  // Event wird an Server gesendet
  await trackServerSideEvent({
    event: 'purchase',
    userId: user.id,
    properties: {
      orderId: orderData.id,
      value: orderData.total,
      currency: 'EUR',
      items: orderData.items
    },
    timestamp: new Date().toISOString()
  });
};

// TrackingManager.swift
class ServerSideTrackingManager {
    static let shared = ServerSideTrackingManager()
    private let apiEndpoint = "https://tracking.your-domain.com/events"

    func track(event: String, properties: [String: Any]) {
        var request = URLRequest(url: URL(string: apiEndpoint)!)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        let eventData: [String: Any] = [
            "event": event,
            "userId": UserDefaults.standard.string(forKey: "userId"),
            "properties": properties,
            "timestamp": ISO8601DateFormatter().string(from: Date()),
            "platform": "iOS",
            "appVersion": Bundle.main.infoDictionary?["CFBundleShortVersionString"]
        ]

        request.httpBody = try? JSONSerialization.data(withJSONObject: eventData)

        URLSession.shared.dataTask(with: request).resume()
    }
}

// Usage
ServerSideTrackingManager.shared.track(
    event: "product_viewed",
    properties: [
        "productId": "123",
        "category": "Electronics",
        "price": 299.99
    ]
)

// ServerSideTracker.kt
class ServerSideTracker(private val context: Context) {
    private val apiEndpoint = "https://tracking.your-domain.com/events"
    private val client = OkHttpClient()

    fun track(event: String, properties: Map<String, Any>) {
        val json = JSONObject().apply {
            put("event", event)
            put("userId", getUserId())
            put("properties", JSONObject(properties))
            put("timestamp", System.currentTimeMillis())
            put("platform", "Android")
            put("appVersion", BuildConfig.VERSION_NAME)
        }

        val request = Request.Builder()
            .url(apiEndpoint)
            .post(json.toString().toRequestBody("application/json".toMediaType()))
            .build()

        client.newCall(request).enqueue(object : Callback {
            override fun onResponse(call: Call, response: Response) {
                // Handle success
            }

            override fun onFailure(call: Call, e: IOException) {
                // Queue for retry
            }
        })
    }
}

// Usage
tracker.track("purchase_completed", mapOf(
    "orderId" to "ORDER-123",
    "revenue" to 149.99,
    "currency" to "EUR"
))

// tracking.js
import AsyncStorage from '@react-native-async-storage/async-storage';

const TRACKING_ENDPOINT = 'https://tracking.your-domain.com/events';
const QUEUE_KEY = '@tracking_queue';

export const trackEvent = async (event, properties = {}) => {
  try {
    const userId = await AsyncStorage.getItem('@user_id');

    const eventData = {
      event,
      userId,
      properties,
      timestamp: new Date().toISOString(),
      platform: Platform.OS,
      appVersion: DeviceInfo.getVersion()
    };

    const response = await fetch(TRACKING_ENDPOINT, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(eventData)
    });

    if (!response.ok) {
      // Queue for retry
      await queueEvent(eventData);
    }
  } catch (error) {
    // Queue for retry
    await queueEvent(eventData);
  }
};

// Usage
import { trackEvent } from './tracking';

trackEvent('screen_view', {
  screenName: 'ProductDetails',
  productId: '123'
});

// server.js
const express = require('express');
const { validateEvent, enrichEvent, sendToAnalytics } = require('./tracking');

const app = express();
app.use(express.json());

app.post('/events', async (req, res) => {
  try {
    // 1. Validate incoming event
    const validatedEvent = validateEvent(req.body);

    // 2. Enrich with server-side data
    const enrichedEvent = await enrichEvent(validatedEvent, {
      ip: req.ip,
      userAgent: req.get('user-agent'),
      geo: await getGeoData(req.ip)
    });

    // 3. Send to analytics platforms
    await Promise.all([
      sendToAnalytics('ga4', enrichedEvent),
      sendToAnalytics('mixpanel', enrichedEvent),
      storeInDatabase(enrichedEvent)
    ]);

    res.status(200).json({ success: true });
  } catch (error) {
    console.error('Tracking error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

app.listen(3000, () => {
  console.log('Tracking server running on port 3000');
});

// Deep Link Tracking
import { trackEvent } from './tracking';

const handleDeepLink = async (url) => {
  const params = parseDeepLinkParams(url);

  await trackEvent('deep_link_opened', {
    source: params.utm_source,
    medium: params.utm_medium,
    campaign: params.utm_campaign,
    url: url
  });

  // Weiterleitung zur Zielseite
  navigate(params.target);
};

// Push Notification Tracking
const trackPushNotification = async (notification) => {
  await trackEvent('push_received', {
    notificationId: notification.id,
    campaign: notification.campaignId,
    title: notification.title
  });
};

const trackPushOpened = async (notification) => {
  await trackEvent('push_opened', {
    notificationId: notification.id,
    campaign: notification.campaignId,
    timeToOpen: Date.now() - notification.receivedAt
  });
};

// iOS In-App Purchase Tracking
func trackPurchase(_ transaction: SKPaymentTransaction) {
    ServerSideTrackingManager.shared.track(
        event: "in_app_purchase",
        properties: [
            "productId": transaction.payment.productIdentifier,
            "transactionId": transaction.transactionIdentifier,
            "revenue": getPrice(for: transaction.payment.productIdentifier),
            "currency": "EUR"
        ]
    )
}

// GA4 Server-Side Events
const sendToGA4 = async (event) => {
  const measurementId = 'G-XXXXXXXXXX';
  const apiSecret = 'YOUR_API_SECRET';

  await fetch(
    `https://www.google-analytics.com/mp/collect?measurement_id=${measurementId}&api_secret=${apiSecret}`,
    {
      method: 'POST',
      body: JSON.stringify({
        client_id: event.userId,
        events: [{
          name: event.event,
          params: {
            ...event.properties,
            engagement_time_msec: '100'
          }
        }]
      })
    }
  );
};

// Firebase Server-Side Integration
import { initializeApp } from 'firebase-admin/app';
import { getAnalytics } from 'firebase-admin/analytics';

const logEvent = async (eventName, params) => {
  const analytics = getAnalytics();
  await analytics.logEvent(eventName, params);
};

// Custom Analytics API
app.post('/analytics/query', async (req, res) => {
  const { startDate, endDate, metrics } = req.body;

  const results = await db.query(`
    SELECT
      event,
      COUNT(*) as count,
      COUNT(DISTINCT user_id) as unique_users
    FROM events
    WHERE timestamp BETWEEN $1 AND $2
    GROUP BY event
  `, [startDate, endDate]);

  res.json(results);
});

// Debug-Modus für Entwicklung
const DEBUG = process.env.NODE_ENV === 'development';

if (DEBUG) {
  console.log('📊 Event received:', {
    event: event.name,
    properties: event.properties,
    timestamp: new Date(event.timestamp).toISOString()
  });
}