Kaufabsicht deiner Besucher bewerten ohne schweres CRM

Du willst wissen, wer deiner Besucher wirklich kurz vorm Kauf steht — ohne ein CRM für 200 €/Monat zu installieren und drei Tage lang Workflows zu verkabeln. Gute Nachricht: ein einfaches First-Party-Pixel (ein JS-Skript, das du auf deine Seite setzt) reicht, um die Signale zu erfassen, die zählen. Der Rest ist gewichtete Arithmetik, die du in SQL oder in einem Cron laufen lässt.

Die Signale, die etwas wert sind (und die, die du wegwerfen kannst)

Der klassische Fehler: 40 Events tracken und das Signal ersäufen. In Wirklichkeit liest sich die Kaufabsicht aus einer Handvoll Verhaltensweisen. Hier sind die, die tatsächlich mit einer Conversion korrelieren, in absteigender Gewichtung.

• Besuch der Pricing-Seite: Signal Nr. 1. Wer `/pricing` öffnet, sieht sich schon als Kunde. Gewichte es stark.
• Multi-Session-Rückkehr: 3 Sessions in 7 Tagen = Neugier, die zum Bedarf wird. Eine einzige Session, selbst eine lange, ist weniger wert als drei kurze, verteilte.
• Aktive Zeit (nicht Seiten-Zeit): miss die engagierte Zeit (Tab sichtbar + Scroll/Klick), nicht den Tab, der während der Mittagspause offen liegt.
• Scrolltiefe auf Schlüsselseiten: 80 % Scroll auf einer Produktseite oder einem Kundencase > 100 % Scroll auf dem Blog.
• 'Bottom-Funnel'-Seiten angesehen: Integrations-Docs, Security-Seite, Vergleich vs. Wettbewerber, Abrechnungs-FAQ. Das sind die Fragen eines Käufers, nicht eines Neugierigen.
• Falsche Signale zum Ignorieren: ein einzelner Home-Pageview, Referral-Traffic von einem Aggregator, Bots (filtere per User-Agent und per Sessions <2s).

Das First-Party-Pixel: was du setzt, was du sendest

First-Party = dein eigener Endpoint, dein eigenes Cookie. Keine Abhängigkeit von einem Drittanbieter-SaaS, keine Blockade durch Drittanbieter-Adblocker, und du bleibst Herr der Daten (DSGVO-freundlich, wenn du bei anonymer Intent + Einwilligung bleibst). Konkret: ein leichtes Skript, das einen Heartbeat sendet, wenn der Tab sichtbar ist, und ein Event auf jeder Schlüsselseite.

// pixel.js — ~30 lignes, posé sur toutes tes pages
const vid = localStorage.getItem('vid') || crypto.randomUUID();
localStorage.setItem('vid', vid);

function send(type, meta = {}) {
  navigator.sendBeacon('/collect', JSON.stringify({
    vid, type, path: location.pathname, ts: Date.now(), meta
  }));
}

send('pageview');

// temps ACTIF : on n'incrémente que si l'onglet est visible
let active = 0;
setInterval(() => {
  if (document.visibilityState === 'visible') {
    active += 5;
    if (active % 30 === 0) send('heartbeat', { active });
  }
}, 5000);

// profondeur de scroll, envoyée une seule fois par palier
let maxScroll = 0;
window.addEventListener('scroll', () => {
  const d = Math.round((scrollY + innerHeight) / document.body.scrollHeight * 100);
  if (d >= maxScroll + 25) { maxScroll = d; send('scroll', { depth: d }); }
}, { passive: true });

Serverseitig macht `/collect` ein rohes `INSERT` in eine Tabelle `events(vid, type, path, ts, meta_jsonb)`. Das war's. Du berechnest nichts on the fly: du speicherst rohe Events und scorest im Batch. Das erspart dir Doppelzähl-Bugs und du kannst die ganze Historie neu scoren, wann immer du die Gewichtung änderst.

Die Scoring-Formel: gewichten, deckeln, abwerten

Der Score eines Besuchers = Summe der Punkte pro Signal, pro Signal gedeckelt (sonst verfälscht dir ein einzelner Scroll-Verrückter alles) und über die Zeit abgewertet (ein Pricing-Besuch von vor 20 Tagen ist nicht mehr so viel wert wie einer von gestern). Hier ein Start-Raster — kalibriere es danach an deinen echten Convertern.

• `/pricing`-Besuch: +25 pro Besuch, Deckel 50.
• Bottom-Funnel-Seite (Docs, Security, Vergleich): +15 je, Deckel 45.
• Eigenständige Session (>30 Min Abstand): +10, Deckel 40 (= 4 Sessions).
• 2-Min-Block aktiver Zeit: +5, Deckel 30.
• Scroll ≥75 % auf Produkt-/Case-Seite: +8, Deckel 16.
• Zeitliche Abwertung: multipliziere den Score jedes Events mit `0.9 ^ (vergangene_tage)`. Ein 7 Tage altes Event wiegt ~48 % seines Anfangswerts.

-- score par visiteur, recalculé chaque heure en cron
WITH scored AS (
  SELECT vid,
    LEAST(SUM(CASE WHEN type='pageview' AND path='/pricing' THEN 25 END), 50) AS pricing,
    LEAST(SUM(CASE WHEN path = ANY(ARRAY['/docs','/security','/vs']) THEN 15 END), 45) AS funnel,
    LEAST(COUNT(DISTINCT date_trunc('hour', to_timestamp(ts/1000))) * 10, 40) AS sessions
  FROM events
  WHERE to_timestamp(ts/1000) > now() - interval '30 days'
  GROUP BY vid
)
SELECT vid, COALESCE(pricing,0)+COALESCE(funnel,0)+COALESCE(sessions,0) AS score
FROM scored ORDER BY score DESC;

Die 'Hot-Lead'-Schwelle und der richtige Moment zum Nachfassen

Eine absolute Schwelle ("80 = hot") altert schlecht. Bevorzuge eine relative Schwelle: die Top 10 % der Scores des gleitenden Monats. Sie kalibriert sich selbst, wenn sich dein Traffic ändert. Konkret: berechne das 90. Perzentil der aktiven Scores und behandle alles darüber als Hot Lead, der innerhalb von 24 h zu bearbeiten ist.

• Zu früh: beim ersten Pricing-Besuch nachfassen = du verschreckst jemanden, der nur Benchmarking gemacht hat. Warte auf ein zweites starkes Signal (Rückkehr ODER Bottom-Funnel-Seite).
• Ideales Fenster: Score überschreitet das 90. Perzentil UND letztes Event < 48 h. Die Absicht ist reif und deine Marke frisch im Gedächtnis.
• Zu spät: hoher Score, aber letztes Event > 10 Tage = Zug verpasst. Fass trotzdem nach, aber mit einem 'wir haben seitdem X gebracht'-Winkel, nicht 'bereit zu kaufen?'.
• Kanal: Hot-Score + bekannte E-Mail (Newsletter, Trial) = persönliche E-Mail innerhalb 24 h. Anonymer Hot-Score = leichtes Retargeting oder In-App-Banner, kein direktes Nachfassen möglich.

Fang minimal an: setz das Pixel diese Woche, speichere die rohen Events, starte die Scoring-Abfrage read-only und schau ihr 10 Tage lang beim Laufen zu ohne irgendetwas nachzufassen. Du siehst schnell, ob deine Scores zur Realität deiner Abschlüsse passen. Erst dann verkabelst du den Slack-Alarm und justierst die Gewichte an deinen echten Convertern. Ein nützliches Intent-Scoring passt in eine Events-Tabelle, eine SQL-Abfrage und einen Cron — den CRM-Moloch hebst du dir für die Zeit auf, wenn du ein Vertriebsteam zu füttern hast.