Zum Inhalt springen

Web Analytics ohne Cookies – Plausible, Umami & DSGVO-konforme Alternativen (2025)

· von

DSGVO-konforme Web Analytics ohne Cookies

~16 Min. Lesezeit · Veröffentlicht am

🎯 Das wichtigste zuerst: Cookie-freie Analytics können in der Regel ohne Cookie-Banner und Einwilligung betrieben werden und sind – bei korrekter Konfiguration – DSGVO-konform. Sie liefern trotzdem alle wichtigen Metriken. Viele Nutzer mit Ad-Blockern werden trotzdem erfasst – insbesondere, wenn du das Script über deine eigene Domain auslieferst. In der Praxis siehst du oft deutlich mehr Daten als mit einem klassischen Google-Analytics-Setup.

Cookie-Banner nerven. Deine Besucher, dich und wahrscheinlich sogar deinen Hund. Die gute Nachricht: Du kannst professionelle Web-Analytics betreiben, ohne einen einzigen Cookie zu setzen. Keine Banner, keine Einwilligung, keine DSGVO-Sorgen – und trotzdem weißt du, was auf deiner Website passiert.

Das Problem mit Google Analytics & DSGVO

Seit dem EuGH-Urteil "Schrems II" (Juli 2020) ist Google Analytics in der EU rechtlich problematisch:

⚠️ Rechtliche Risiken mit Google Analytics:
• Datentransfer in die USA (kein angemessenes Datenschutzniveau)
• Cookies erfordern explizite Einwilligung
• Bußgelder bis 20 Mio. € oder 4% des Jahresumsatzes
• Österreich, Frankreich, Italien: GA bereits als rechtswidrig eingestuft
• Deutsche Datenschutzbehörden prüfen verstärkt

Dazu kommt: 30-50% der Nutzer lehnen Tracking-Cookies ab, Ad-Blocker blockieren Google Analytics komplett. Du verlierst also massiv Daten.

Wie funktioniert Analytics ohne Cookies?

Cookie-freie Tools nutzen andere Methoden zur Besuchererkennung:

// So generieren cookie-freie Tools eine Session-ID (vereinfacht)
function generateSessionHash(request) {
  const components = [
    request.ip.substr(0, 16),        // IP-Adresse (anonymisiert)
    request.headers['user-agent'],    // Browser
    request.headers['accept-language'], // Sprache
    new Date().toDateString(),        // Datum (Daily Salt)
    'your-site-salt'                  // Site-spezifischer Salt
  ];
  
  // Hash generieren (nicht rückverfolgbar)
  return crypto
    .createHash('sha256')
    .update(components.join('|'))
    .digest('hex');
}

// Dieser Hash gilt nur für 24h, dann wird neu generiert
// → Kein permanentes Tracking, DSGVO-konform!
💡 Datenschutz by Design: Der Hash kann nicht zurückverfolgt werden, gilt nur 24 Stunden und wird täglich neu generiert. Keine persistente Nutzer-ID = keine Einwilligung nötig!

Die Top 5 Cookie-freien Analytics-Tools

ToolPreis/MonatSelf-HostFeaturesBeste für
PlausibleAb 9€ (10k Views)✅ (Docker)Einfach, schnell, EventsEinsteiger, SaaS
UmamiKostenlos / 9$ Cloud✅ (Node.js)Open Source, RealtimeEntwickler, Self-Host
MatomoAb 19€ / Kostenlos✅ (PHP)Umfangreich, E-CommerceEnterprises, Shops
FathomAb 14$ (100k Views)❌EU-Hosting, UptimeAgenturen, Premium
Simple AnalyticsAb 19€❌Tweet-Viewer, GoalsMarketing Teams

Plausible Analytics – Der Einsteiger-Freund

Plausible ist mein Favorit für die meisten Projekte: Simpel, schnell, günstig.

Quick Setup (SaaS-Version)

<!-- In den <head> deiner Seite -->
<script defer data-domain="deine-domain.de" 
        src="https://plausible.io/js/script.js"></script>

<!-- Mit Custom Events -->
<script defer data-domain="deine-domain.de" 
        src="https://plausible.io/js/script.tagged-events.js"></script>

Custom Events tracken

// Einfache Events
document.addEventListener('DOMContentLoaded', function() {
  // Download tracking
  document.querySelectorAll('a[download]').forEach(link => {
    link.addEventListener('click', () => {
      plausible('Download', {
        props: {
          file: link.getAttribute('download')
        }
      });
    });
  });
  
  // Newsletter Signup
  document.getElementById('newsletter-form')?.addEventListener('submit', (e) => {
    e.preventDefault();
    // Form handling...
    plausible('Newsletter', {
      props: {
        source: 'footer'
      }
    });
  });
  
  // 404 Tracking
  if (document.title.includes('404')) {
    plausible('404', {
      props: {
        path: window.location.pathname
      }
    });
  }
});

Self-Hosting mit Docker

# docker-compose.yml für Plausible Self-Hosting
version: '3.3'
services:
  plausible_db:
    image: postgres:14-alpine
    restart: always
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=postgres

  plausible_events_db:
    image: clickhouse/clickhouse-server:22.6-alpine
    restart: always
    volumes:
      - event-data:/var/lib/clickhouse
      - ./clickhouse/clickhouse-config.xml:/etc/clickhouse-server/config.d/logging.xml:ro
      - ./clickhouse/clickhouse-user-config.xml:/etc/clickhouse-server/users.d/logging.xml:ro
    ulimits:
      nofile:
        soft: 262144
        hard: 262144

  plausible:
    image: plausible/analytics:latest
    restart: always
    command: sh -c "sleep 10 && /entrypoint.sh db migrate && /entrypoint.sh run"
    depends_on:
      - plausible_db
      - plausible_events_db
    ports:
      - 8000:8000
    environment:
      - BASE_URL=https://analytics.deine-domain.de
      - SECRET_KEY_BASE=your-64-char-secret-key-here
      - DATABASE_URL=postgres://postgres:postgres@plausible_db:5432/plausible_db
      - CLICKHOUSE_DATABASE_URL=http://plausible_events_db:8123/plausible_events_db

volumes:
  db-data:
  event-data:
✅ Plausible Vorteile:
• Sehr kleines Script (~1 KB) im Vergleich zu GA
• Öffentliche Dashboards möglich
• API für Custom Dashboards
• WordPress Plugin verfügbar
• EU-Server (DSGVO++)
❌ Plausible Nachteile:
• Keine User Flows
• Kein A/B Testing
• Limitierte Segmentierung
• Kein E-Commerce Tracking
• Weniger Details als GA

Umami – Der Open-Source-Champion

Umami ist komplett kostenlos, Open Source und perfekt für Entwickler:

Installation mit Docker

# Quick Start mit Docker
docker run -d \
  --name umami \
  -p 3000:3000 \
  -e DATABASE_URL=postgresql://username:password@host:port/database \
  -e DATABASE_TYPE=postgresql \
  -e HASH_SALT=your-random-salt \
  ghcr.io/umami-software/umami:postgresql-latest

Oder mit Node.js

# Repository klonen
git clone https://github.com/umami-software/umami.git
cd umami

# Dependencies installieren
npm install

# Database Setup (PostgreSQL oder MySQL)
npm run build-db

# Build
npm run build

# Start
npm start # Läuft auf Port 3000

Umami Integration

<!-- Tracking Script -->
<script async src="https://analytics.deine-domain.de/script.js" 
        data-website-id="your-website-id"></script>

<!-- Custom Events mit data-Attributen -->
<button data-umami-event="signup-button">
  Newsletter abonnieren
</button>

<!-- Mit Event-Properties -->
<button data-umami-event="purchase" 
        data-umami-event-product="T-Shirt"
        data-umami-event-price="29.99">
  Kaufen
</button>

Umami API nutzen

// Daten via API abrufen
async function getAnalyticsData() {
  const token = 'your-api-token';
  const websiteId = 'your-website-id';
  
  // Stats der letzten 7 Tage
  const response = await fetch(`https://analytics.deine-domain.de/api/websites/${websiteId}/stats`, {
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    },
    method: 'POST',
    body: JSON.stringify({
      startAt: Date.now() - 7 * 24 * 60 * 60 * 1000,
      endAt: Date.now()
    })
  });
  
  const data = await response.json();
  console.log(data);
  // { pageviews: 1234, visitors: 567, bounces: 123, ... }
}

// Custom Dashboard bauen
function displayStats(stats) {
  document.getElementById('visitors').textContent = stats.visitors.toLocaleString();
  document.getElementById('pageviews').textContent = stats.pageviews.toLocaleString();
  document.getElementById('bounce-rate').textContent = 
    `${(stats.bounces / stats.visitors * 100).toFixed(1)}%`;
}

Matomo – Die Enterprise-Lösung

Matomo (früher Piwik) ist der Platzhirsch für große Projekte:

Matomo ohne Cookies konfigurieren

// Cookie-freies Tracking aktivieren
var _paq = window._paq = window._paq || [];
_paq.push(['disableCookies']); // Keine Cookies!
_paq.push(['trackPageView']);
_paq.push(['enableLinkTracking']);

(function() {
  var u="https://analytics.deine-domain.de/";
  _paq.push(['setTrackerUrl', u+'matomo.php']);
  _paq.push(['setSiteId', '1']);
  var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
  g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
})();

E-Commerce Tracking mit Matomo

// Produkt-Views
_paq.push(['setEcommerceView',
  'SKU123',           // SKU
  'Cooles T-Shirt',   // Name
  ['Kleidung', 'Shirts'], // Kategorien
  29.99               // Preis
]);

// Warenkorb tracken
_paq.push(['addEcommerceItem',
  'SKU123',           // SKU
  'Cooles T-Shirt',   // Name  
  ['Kleidung'],       // Kategorie
  29.99,              // Preis
  2                   // Anzahl
]);

// Bestellung tracken
_paq.push(['trackEcommerceOrder',
  'ORDER-12345',      // Order ID
  59.98,              // Gesamt
  49.98,              // Subtotal
  5.00,               // Versand
  5.00,               // Steuer
  false               // Rabatt
]);

Migration von Google Analytics

Schritt 1: Parallel tracken (Übergangsphase)

<!-- Beide Scripts parallel laufen lassen -->
<!-- Google Analytics (noch) -->
<script async src="https://www.googletagmanager.com/gtag/js?id=GA_ID"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());
  gtag('config', 'GA_ID');
</script>

<!-- Plausible (neu) -->
<script defer data-domain="deine-domain.de" 
        src="https://plausible.io/js/script.js"></script>

Schritt 2: Goals/Events mappen

// Alt: Google Analytics Events
gtag('event', 'purchase', {
  'value': 29.99,
  'currency': 'EUR',
  'items': [{
    'id': 'SKU123',
    'name': 'T-Shirt',
    'category': 'Apparel',
    'quantity': 1,
    'price': 29.99
  }]
});

// Neu: Plausible Events (vereinfacht)
plausible('Purchase', {
  props: {
    value: '29.99',
    product: 'T-Shirt'
  }
});

// Oder Umami
umami.track('purchase', {
  value: 29.99,
  product: 'T-Shirt'
});

Schritt 3: Historische Daten exportieren

# GA4 Daten via API exportieren (Python)
from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import RunReportRequest
import pandas as pd

def export_ga4_data():
    client = BetaAnalyticsDataClient()
    
    request = RunReportRequest(
        property=f"properties/YOUR_PROPERTY_ID",
        dimensions=[
            {"name": "date"},
            {"name": "pagePath"},
            {"name": "country"}
        ],
        metrics=[
            {"name": "sessions"},
            {"name": "totalUsers"},
            {"name": "screenPageViews"}
        ],
        date_ranges=[{
            "start_date": "2024-01-01",
            "end_date": "2024-12-31"
        }]
    )
    
    response = client.run_report(request)
    
    # In DataFrame konvertieren
    data = []
    for row in response.rows:
        data.append({
            'date': row.dimension_values[0].value,
            'page': row.dimension_values[1].value,
            'country': row.dimension_values[2].value,
            'sessions': row.metric_values[0].value,
            'users': row.metric_values[1].value,
            'pageviews': row.metric_values[2].value
        })
    
    df = pd.DataFrame(data)
    df.to_csv('ga4_export.csv', index=False)
    
    return df

Proxy-Setup für maximale Performance

Analytics-Scripts über eigene Domain ausliefern = weniger Blocking, bessere Performance:

Nginx Proxy Config

# /etc/nginx/sites-available/analytics-proxy
server {
    listen 443 ssl http2;
    server_name analytics.deine-domain.de;
    
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;
    
    # Plausible Proxy
    location /js/ {
        proxy_pass https://plausible.io/js/;
        proxy_set_header Host plausible.io;
        
        # Cache für 1 Tag
        proxy_cache_valid 200 1d;
        add_header Cache-Control "public, max-age=86400";
    }
    
    location /api/event {
        proxy_pass https://plausible.io/api/event;
        proxy_set_header Host plausible.io;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # Wichtig: Original-IP weitergeben
        proxy_set_header X-Real-IP $remote_addr;
        
        proxy_buffering off;
        proxy_http_version 1.1;
    }
}

Cloudflare Workers Proxy

// Plausible via Cloudflare Workers proxyen
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const url = new URL(request.url)
  
  // Script-Requests
  if (url.pathname.startsWith('/js/')) {
    const response = await fetch('https://plausible.io' + url.pathname)
    
    // Mit Cache-Headers
    const newResponse = new Response(response.body, response)
    newResponse.headers.set('Cache-Control', 'public, max-age=86400')
    
    return newResponse
  }
  
  // Event-Requests
  if (url.pathname === '/api/event') {
    const newRequest = new Request('https://plausible.io/api/event', {
      method: request.method,
      headers: request.headers,
      body: request.body
    })
    
    return fetch(newRequest)
  }
  
  return new Response('Not found', { status: 404 })
}

Custom Dashboards bauen

Alle Tools bieten APIs für eigene Dashboards:

<!-- Real-time Visitor Counter -->
<div id="visitor-counter" class="stats-widget">
  <div class="stat">
    <span class="number" id="current-visitors">-</span>
    <span class="label">Live Besucher</span>
  </div>
  <div class="stat">
    <span class="number" id="today-visitors">-</span>
    <span class="label">Heute</span>
  </div>
  <div class="stat">
    <span class="number" id="month-visitors">-</span>
    <span class="label">Diesen Monat</span>
  </div>
</div>

<script>
// Live-Updates via Plausible API
async function updateStats() {
  const response = await fetch('https://plausible.io/api/v1/stats/aggregate', {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  });
  
  const data = await response.json();
  
  document.getElementById('current-visitors').textContent = 
    data.results.visitors.value;
  document.getElementById('today-visitors').textContent = 
    data.results.pageviews.value;
}

// Update alle 30 Sekunden
setInterval(updateStats, 30000);
updateStats();
</script>

Rechtssicherheit: Das musst du beachten

✅ Keine Cookies = Keine Banner
Wenn kein Cookie gesetzt wird, brauchst du keine Einwilligung
✅ Datenschutzerklärung anpassen
Auch cookie-freie Tools müssen erwähnt werden
✅ IP-Anonymisierung
Alle Tools hier anonymisieren IPs automatisch
✅ Kein User-Profiling
Session-Hashes verfallen täglich
✅ Hosting in der EU
Self-Host oder EU-Server wählen
✅ Opt-Out anbieten
Freiwillig, aber user-freundlich

Muster-Datenschutzerklärung

<!-- Beispiel für Plausible in der Datenschutzerklärung -->
<h3>Web-Analyse mit Plausible</h3>
<p>
  Diese Website nutzt Plausible Analytics, einen datenschutzfreundlichen 
  Webanalysedienst ohne Cookies. Plausible erfasst anonymisierte Daten 
  über Websitebesuche ohne personenbezogene Informationen zu speichern. 
  Es werden keine Cookies gesetzt und keine persönlichen Daten gesammelt.
</p>
<p>
  Folgende Daten werden erfasst:
  • Referrer (woher Sie kommen)
  • Aufgerufene Seiten
  • Verwendeter Browser und Betriebssystem
  • Verweildauer
  • Land (ohne genauen Standort)
</p>
<p>
  Die Daten werden auf Servern in der EU gespeichert. 
  Rechtsgrundlage: Art. 6 Abs. 1 lit. f DSGVO (berechtigtes Interesse).
</p>

Performance-Vergleich: Script-Größen

ToolScript-GrößeRequestsLoad TimeImpact auf Core Web Vitals
Plausible< 1 KB2~15msMinimal
Umami2 KB2~20msMinimal
Fathom< 1 KB2~15msMinimal
Matomo (no cookies)22 KB3~80msGering
Google Analytics 445+ KB4+~200msSpürbar

Kosten-Nutzen-Analyse

📊 Rechenbeispiel für 50.000 Pageviews/Monat:
• Plausible Cloud: 19€/Monat
• Umami Self-Host: ~5€ VPS-Kosten
• Matomo Cloud: 29€/Monat
• Fathom: 14$/Monat
• Google Analytics: "Kostenlos" (aber Daten-Preis)

Versteckte Kosten bei GA: Cookie-Banner-Tool (5-50€/Monat), DSGVO-Beratung, mögliche Bußgelder, verlorene Conversions durch Banner

Quick Decision Matrix

🎯 Welches Tool für wen?

Plausible wählen wenn:
✓ Du schnell starten willst
✓ Einfachheit wichtiger als Features ist
✓ Du öffentliche Stats teilen willst

Umami wählen wenn:
✓ Du Self-Hosting bevorzugst
✓ Kosten minimieren willst
✓ Du technisch versiert bist

Matomo wählen wenn:
✓ Du E-Commerce trackst
✓ Viele Details brauchst
✓ Enterprise-Features wichtig sind

Fathom wählen wenn:
✓ Premium-Support wichtig ist
✓ Du Uptime-Monitoring brauchst
✓ Budget kein Problem ist

Setup in 5 Minuten: Der Quickstart

# Option 1: Plausible SaaS (am schnellsten)
# 1. Account auf plausible.io erstellen
# 2. Domain hinzufügen
# 3. Script-Tag kopieren und einfügen
# Fertig!

# Option 2: Umami mit Docker (self-hosted)
# 1. Docker Compose erstellen
cat > docker-compose.yml << EOF
version: '3'
services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:umami@db:5432/umami
      DATABASE_TYPE: postgresql
      HASH_SALT: $(openssl rand -base64 32)
    depends_on:
      - db
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: umami
    volumes:
      - umami-db:/var/lib/postgresql/data
volumes:
  umami-db:
EOF

# 2. Starten
docker-compose up -d

# 3. Browser öffnen: http://localhost:3000
# Default Login: admin / umami

# 4. Website hinzufügen, Script-Tag kopieren
# Fertig!

Fazit: Privacy First ist die Zukunft

Cookie-freie Analytics sind nicht nur DSGVO-konform, sie sind auch nutzerfreundlicher und oft genauer als Google Analytics:

✅ Keine nervigen Cookie-Banner
✅ DSGVO-konform bei korrekter Konfiguration
✅ Erfasst auch Ad-Blocker-Nutzer
✅ Schnellere Ladezeiten
✅ Keine Daten an US-Konzerne
✅ Oft günstiger als GA + Cookie-Tool

„Privacy ist kein Feature, es ist ein Grundrecht. Respektiere deine Nutzer, und sie respektieren dich."

– Marko Saric, Plausible Co-Founder
🚀 Starte heute:
1. Wähle ein Tool (Empfehlung: Plausible für SaaS, Umami für Self-Host)
2. Installiere es parallel zu GA
3. Vergleiche 30 Tage lang die Daten
4. Schalte GA ab und entferne Cookie-Banner
5. Genieße bessere Performance und zufriedene Nutzer!

Mehr zu Performance-Optimierung findest du in Core Web Vitals verbessern.
Für rechtssichere Websites lies Website Relaunch – SEO-Planung.
Self-Hosting mit Docker erkläre ich in Docker für Webentwickler.

Analytics DSGVO Privacy Plausible Umami Matomo Cookie-free Self-Hosting