Einen Website-Change-Tracker mit Python erstellenSnapshots und SHA-256-Diffs

Viele Seiten sind es wert, auf Änderungen überwacht zu werden: die Preisseite eines Wettbewerbers, der Lagerstatus eines Produkts, ein Richtlinien- oder Nutzungsbedingungsdokument, ein Stellenmarkt, eine Release-Notes-Seite. Die Information ist öffentlich, aber die Änderung ist das eigentliche Signal, das Sie interessiert, und ein Tab von Hand zu aktualisieren skaliert über ein paar Seiten hinaus nicht. Was Sie möchten, ist ein Skript, das für Sie prüft und Sie nur informiert, wenn etwas anders ist.

Diese Anleitung zeigt Ihnen, wie Sie zuverlässig einen Website-Change-Tracker in Python aufbauen. Sie bauen ein kleines, ausführbares Tool, das eine Seite über die Crawling API abruft, den aussagekräftigen Text extrahiert, einen SHA-256-Fingerabdruck berechnet, jeden Snapshot auf der Festplatte speichert, den neuen Fingerabdruck mit dem letzten vergleicht, um eine Änderung zu erkennen, und die gesamte Prüfung nach einem Zeitplan ausführt. Der Ansatz ist generisch: er funktioniert auf jeder öffentlichen Seite, auf die Sie ihn richten, nicht auf einer bestimmten Site.

Was Sie bauen werden

Ein Python-Skript, das eine oder mehrere öffentliche URLs nimmt, jede Seite über die Crawling API abruft, sie auf vergleichbaren Text reduziert, diesen Text mit einem Fingerabdruck versieht und meldet, ob sich die Seite seit dem letzten Lauf geändert hat. Jede Komponente ist eine kleine Funktion, die Sie lesen und wiederverwenden können. Die Teile sind:

• Fetcher ruft das Seiten-HTML über die Crawling API ab, sodass Blockierungen und JavaScript-Rendering für Sie erledigt werden.
• Extractor entfernt Skripte, Stile, Navigation und Footer und hinterlässt den lesbaren Textkörper.
• Fingerabdruck ein SHA-256-Hash des bereinigten Textes, sodass ein geändertes Wort einen vollständig anderen Wert erzeugt.
• Store eine JSON-Datei, die jede URL ihrem letzten Fingerabdruck zuordnet, plus der letzte Text für Diffs.
• Comparator lädt den vorherigen Fingerabdruck, vergleicht und meldet geändert oder unverändert.
• Scheduler eine Schleife mit einem Sleep-Intervall oder ein Cron-Eintrag, damit die Prüfung selbständig läuft.

Warum eine einfache Anfrage nicht ausreicht

Sie könnten das mit einem nackten HTTP-Client schreiben und die API ganz überspringen, und auf einer einfachen statischen Seite würde es sogar funktionieren. Das Problem beginnt bei echten Zielen. Viele Sites drosseln oder blockieren automatisierte Anfragen direkt: Eine Datacenter-IP, die dieselbe URL in festen Intervallen aufruft, ist ein leicht zu erkennendes Muster, und ein Monitor ist per Definition automatisierter Traffic. Andere Seiten bauen ihren Inhalt im Browser mit JavaScript auf, sodass das rohe HTML einer normalen Anfrage nahezu eine leere Hülle ist und Ihr Fingerabdruck die Hülle statt des eigentlich überwachten Inhalts verfolgt.

Ein zuverlässiger Tracker benötigt also zwei Dinge von jedem Abruf: eine IP, die die Site als echten Besucher liest, und, wenn die Seite clientseitig gerendert wird, einen Browser, der die Skripte ausführt, bevor das HTML zurückkommt. Das können Sie selbst mit einem Headless-Browser und einem Pool von rotierenden Residential-Proxys zusammenstellen, aber diesen Stack gesund zu halten ist der Großteil der Arbeit. Die Crawling API faltet beides in einen Aufruf: schicken Sie ihr die URL, optional einen JavaScript-Token, und sie gibt fertiges HTML zum Erstellen des Fingerabdrucks zurück.

Es gibt einen zweiten Grund, warum der Vergleich selbst sorgfältig sein muss, getrennt davon, wie Sie abrufen. Rohes HTML ändert sich ständig auf Weisen, die Sie nicht interessieren: Inline-Skripte, Ad-Slots, eingebettete Zeitstempel, CSRF-Tokens, dynamische Widgets. Wenn Sie die rohe Antwort hashen, erhalten Sie fast bei jedem Lauf ein falsches Positiv. Die Seite zuerst auf ihren lesbaren Text zu reduzieren ist das, was den Fingerabdruck zu einem echten Signal statt Rauschen macht.

Voraussetzungen

Einige Dinge müssen zuerst vorhanden sein. Keine davon dauert lang.

Grundlegende Python-Kenntnisse. Sie sollten damit vertraut sein, ein Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Wenn BeautifulSoup neu für Sie ist, behandelt unser Leitfaden zur Verwendung von BeautifulSoup in Python das Parsing, das dieses Tutorial voraussetzt.

Python 3.10 oder neuer. Bestätigen Sie Ihre Version mit python --version. Der Code verwendet die str | None Typhinweis-Syntax, die 3.10 benötigt. Wenn Sie ihn nicht haben, installieren Sie ihn von python.org.

Ein Crawlbase-Account und -Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihren Token von der Account-Docs-Seite. Der kostenlose Tarif enthält bis zu 20.000 Anfragen, was mehr als genug ist, um einen Tracker zu testen. Behandeln Sie den Token wie ein Passwort und halten Sie ihn aus der Versionskontrolle heraus: Der Code unten liest ihn aus der Umgebungsvariablen CRAWLBASE_TOKEN.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Abhängigkeiten isoliert bleiben, dann installieren Sie die beiden Drittanbieter-Bibliotheken. Hashing, Speicherung, Scheduling und Diffing kommen alle aus der Python-Standardbibliothek (hashlib, json, time und difflib), sodass für diese nichts extra installiert werden muss.

python --version

python -m venv tracker_env
source tracker_env/bin/activate

pip install requests beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit tracker_env\Scripts\activate statt der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: requests sendet den HTTP-Aufruf an die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, damit Sie den lesbaren Text herausziehen können.

Schritt 1: Die Seite über die Crawling API abrufen

Beginnen Sie damit, zu bestätigen, dass Sie die Seite überhaupt abrufen können. Die folgende Funktion liest Ihren Token, baut die Crawling-API-Anfrage-URL mit der URL-kodierten Zielseite auf, sendet die Anfrage und gibt das HTML zurück. Das Überprüfen des Antwortstatus hält Fehler laut statt still.

import os
from urllib.parse import quote
import requests

CRAWLBASE_API_URL = "https://api.crawlbase.com"

def fetch_page(url: str, token: str | None = None) -> str:
    api_token = token or os.environ.get("CRAWLBASE_TOKEN", "")
    if not api_token:
        raise ValueError("Set CRAWLBASE_TOKEN or pass token=")
    api_url = f"{CRAWLBASE_API_URL}/?token={api_token}&url={quote(url)}"
    response = requests.get(api_url, timeout=30)
    response.raise_for_status()
    return response.text

if __name__ == "__main__":
    html = fetch_page("https://example.com")
    print(html[:300])

Führen Sie dies mit gesetztem Token aus (export CRAWLBASE_TOKEN="your_token") und Sie sollten die ersten paar hundert Zeichen echten Seiten-HTMLs sehen. Diese einzelne Bestätigung ist wichtig: Sie beweist, dass die Anfrage die Seite erreicht und mit Inhalt zurückkommt, bevor Sie etwas darauf aufbauen. Die Aufrufe timeout=30 und raise_for_status() sind bewusst, und der Abschnitt zur Fehlerbehandlung baut später auf beiden auf. Wenn das Ziel seinen Inhalt mit JavaScript rendert, fügen Sie statt des Standard-Tokens einen JavaScript-Token hinzu, damit die Seite gerendert wird, bevor das HTML zurückgegeben wird.

Schritt 2: Den Inhalt extrahieren und mit einem Fingerabdruck versehen

Rohes HTML zu vergleichen ist unzuverlässig, daher reduziert der nächste Schritt die Seite auf lesbaren Text und hasht ihn dann. Der Extraktor lädt das HTML in BeautifulSoup, lässt Elemente fallen, die sich ändern, ohne etwas zu bedeuten (script, style, nav, footer), zieht den sichtbaren Text heraus und kollabiert Leerzeichen, sodass kosmetische Umbrüche nicht als Änderungen registriert werden.

import hashlib
from bs4 import BeautifulSoup

def extract_monitorable_text(html: str) -> str:
    soup = BeautifulSoup(html, "html.parser")
    for tag in soup(["script", "style", "nav", "footer"]):
        tag.decompose()
    text = soup.get_text(separator=" ", strip=True)
    return " ".join(text.split())

def content_fingerprint(text: str) -> str:
    return hashlib.sha256(text.encode("utf-8")).hexdigest()

Der Fingerabdruck ist ein SHA-256-Hash dieses bereinigten Textes. Ein Hash ist eine festlängenige Zeichenkette, die aus der Eingabe abgeleitet wird, und jede Änderung der Eingabe, selbst ein einzelnes Zeichen, erzeugt eine vollständig andere Ausgabe. Diese Eigenschaft ist genau das, was ein Tracker möchte: Anstatt ganze Seiten zu speichern und byteweise zu vergleichen, speichern Sie eine 64-Zeichen-Zeichenkette pro URL und vergleichen diese. Der Vergleich ist schnell, der Speicher ist winzig und kleine Änderungen werden dennoch erkannt. Kombinieren Sie das mit unserem allgemeinen Python-Scraping-Leitfaden, wenn Sie den Extraktor erweitern möchten, um einen bestimmten Bereich der Seite statt des gesamten Körpers anzusteuern.

Schritt 3: Snapshots speichern und vergleichen

Um eine Änderung zu erkennen, muss sich das Tool den letzten Lauf merken. Zwei kleine JSON-Dateien halten den Zustand: snapshots.json ordnet jede URL ihrem letzten Fingerabdruck zu, und snapshots_text.json bewahrt den letzten extrahierten Text auf, damit Sie einen menschenlesbaren Diff anzeigen können, wenn sich etwas bewegt. Die Ladefunktion gibt beim ersten Lauf ein leeres Dict zurück, anstatt zu scheitern.

import json
from pathlib import Path

def load_json(path: str | Path) -> dict[str, str]:
    p = Path(path)
    if not p.exists():
        return {}
    with open(p, encoding="utf-8") as f:
        return json.load(f)

def save_json(data: dict[str, str], path: str | Path) -> None:
    with open(path, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2)

def check_for_change(url: str, current_hash: str, snapshots: dict[str, str]) -> bool:
    previous = snapshots.get(url)
    if previous is None:
        return True
    return previous != current_hash

Die Vergleichslogik ist das Herzstück des Trackers und ist bewusst einfach. check_for_change schlägt den gespeicherten Fingerabdruck der URL nach. Wenn keiner vorhanden ist, ist das das erste Mal, dass Sie die Seite sehen, also meldet es eine Änderung und der neue Fingerabdruck wird gespeichert. Wenn einer vorhanden ist, gibt es zurück, ob die beiden sich unterscheiden. Der erste Lauf auf jeder URL meldet immer geändert genau aus diesem Grund, was erwartet wird und kein Bug ist.

Verdrahten Sie jetzt die Teile in einem Lauf. Die folgende Funktion durchläuft die URLs, ruft jede ab und erstellt einen Fingerabdruck, entscheidet, ob sie sich geändert hat, gibt einen unified Diff gegen den gespeicherten Text aus, wenn das der Fall war, und speichert den aktualisierten Zustand am Ende, damit der nächste Lauf etwas zum Vergleichen hat. Der Diff verwendet das difflib-Modul der Standardbibliothek, keine zusätzliche Abhängigkeit.

import difflib

def run_once(urls: list[str], hash_path="snapshots.json",
             text_path="snapshots_text.json") -> None:
    snapshots = load_json(hash_path)
    snapshot_texts = load_json(text_path)

    for url in urls:
        html = fetch_page(url)
        text = extract_monitorable_text(html)
        if not text:
            print(f"[warn] empty text, skipping {url}")
            continue
        fingerprint = content_fingerprint(text)

        if check_for_change(url, fingerprint, snapshots):
            print(f"[changed] {url}")
            old = snapshot_texts.get(url, "")
            diff = difflib.unified_diff(
                old.split(), text.split(),
                lineterm="", n=0)
            print(" ".join(diff)[:500])
        else:
            print(f"[no change] {url}")

        snapshots[url] = fingerprint
        snapshot_texts[url] = text

    save_json(snapshots, hash_path)
    save_json(snapshot_texts, text_path)

Sowohl den Fingerabdruck als auch den Text zu speichern ermöglicht es zukünftigen Läufen, eine Änderung zu erkennen und sie zu erklären. Der Fingerabdruck beantwortet "hat sich etwas geändert", und der gespeicherte Text lässt difflib antworten "was hat sich geändert." Wenn Sie nur das Ja/Nein-Signal benötigen, können Sie die Textdatei weglassen und nur die Fingerabdruckübersicht behalten.

Schritt 4: Den Tracker nach einem Zeitplan ausführen

Ein Change-Tracker ist nur nützlich, wenn er selbständig läuft. Es gibt zwei saubere Wege dazu. Der erste ist ins Skript eingebaut: eine optionale Intervallschleife, die jede URL alle N Sekunden erneut prüft, bis Sie sie stoppen. Der zweite ist, das Betriebssystem einen einzelnen Durchlauf auf einem Timer mit cron ausführen zu lassen. Unten ist der CLI-Einstiegspunkt mit sowohl dem Einmal- als auch dem Intervallmodus.

import argparse
import time

def main() -> None:
    parser = argparse.ArgumentParser(description="Website change tracker")
    parser.add_argument("urls", nargs="+", help="public URLs to monitor")
    parser.add_argument("--interval", type=float, metavar="SECONDS",
        help="re-check every SECONDS (e.g. 3600 for hourly); Ctrl+C to stop")
    args = parser.parse_args()

    while True:
        run_once(args.urls)
        if args.interval is None:
            break
        time.sleep(args.interval)

if __name__ == "__main__":
    main()

Führen Sie eine einzelne Prüfung durch oder lassen Sie es stündlich laufen:

export CRAWLBASE_TOKEN="your_token"

# one pass, then exit
python tracker.py https://example.com

# check every hour until you stop it
python tracker.py https://example.com --interval 3600

Die Intervallschleife ist die einfachste Option und hält den Prozess an einem Ort, was praktisch ist, während Sie testen. Für ein unbeaufsichtigtes Produktions-Setup ist cron in der Regel die bessere Wahl: es überlebt Neustarts und blockiert kein Terminal. Ein Crontab-Eintrag, der stündlich einen einzelnen Durchlauf ausführt und die Ausgabe an ein Log anhängt, sieht so aus:

# run at the top of every hour
0 * * * * cd /path/to/project && \
  CRAWLBASE_TOKEN=your_token \
  ./tracker_env/bin/python tracker.py https://example.com >> tracker.log 2>&1

Unter Windows ist das Äquivalent der Task-Scheduler, der denselben Einmal-Befehl auf einem Trigger ausführt. In jedem Fall lassen Sie das --interval-Flag weg, wenn cron oder der Task-Scheduler das Timing übernimmt, da der Scheduler die Wiederholung bereits handhabt.

Wie die Ausgabe aussieht

Das Skript gibt eine Zeile pro URL pro Lauf aus, plus einen gekürzten Diff, wenn sich eine Seite geändert hat. Das erste Mal, wenn Sie eine URL prüfen, meldet sie immer geändert, weil noch kein gespeicherter Fingerabdruck vorhanden ist, und der Snapshot wird für das nächste Mal geschrieben:

# first run: no snapshot exists yet
[changed] https://example.com

# later run, content edited
[changed] https://example.com
--- +++ @@ -Old pricing copy +New pricing copy

# later run, nothing moved
[no change] https://example.com

Der Zustand auf der Festplatte ist genauso lesbar. snapshots.json ist eine flache Zuordnung von URL zu Fingerabdruck, was alles ist, was der Vergleich benötigt:

{
  "https://example.com": "3e1f9c...a7d2",
  "https://example.com/pricing": "b04c88...11ef"
}

Fehler handhaben und skalieren

Ein lange laufender Monitor wird Fehler treffen, und wie er damit umgeht entscheidet, ob er weiterläuft. Drei Fälle kommen ständig vor. Timeouts: Der Aufruf requests.get(timeout=30) wirft eine Ausnahme, wenn die API nicht rechtzeitig antwortet, also verpacken Sie den Abruf und wiederholen Sie mit exponentiellem Backoff, anstatt eine langsame Antwort den Lauf töten zu lassen. HTTP-Fehler: raise_for_status() wandelt 4xx- und 5xx-Antworten in Ausnahmen um; protokollieren Sie den Status und die URL, dann überspringen Sie diese URL und fahren Sie mit den restlichen fort. Leere Extraktionen: Wenn extract_monitorable_text eine leere Zeichenkette zurückgibt, überspringen Sie den Vergleich und protokollieren Sie eine Warnung, anstatt eine falsche Änderung zu erfassen, was die if not text-Absicherung in run_once bereits tut.

def fetch_with_retry(url: str, retries: int = 3,
                     backoff: float = 2.0) -> str:
    for attempt in range(retries):
        try:
            return fetch_page(url)
        except requests.exceptions.RequestException:
            if attempt < retries - 1:
                time.sleep(backoff ** attempt)
            else:
                raise

Das Skalieren von einer Seite auf viele folgt natürlich. Mehr URLs zu verfolgen ist nur eine längere Liste, die an run_once übergeben wird. Um große Listen zu beschleunigen, rufen Sie parallel mit concurrent.futures.ThreadPoolExecutor ab, da die Arbeit I/O-gebunden ist. Um Hunderte von Seiten zu verfolgen, verschieben Sie den Zustand wie oben erwähnt von JSON zu SQLite. Und wenn eines Ihrer Ziele Inhalte clientseitig rendert, wechseln Sie den Abruf zu einem JavaScript-Token, damit die Seite vor der Extraktion gerendert wird: unsere Hinweise zum Scrapen von JavaScript-Seiten mit Python beschreiben, wann das notwendig ist.

Änderungen verantwortungsvoll verfolgen

Ein Change-Tracker ist automatisierter Traffic, also betreiben Sie ihn so, wie Sie einen gegen Ihre eigene Site betrieben haben möchten. Pollieren Sie in einem Rhythmus, der dazu passt, wie oft die Seite tatsächlich ändert: alle 15 bis 60 Minuten für schnell wechselnde Nachrichten oder Dashboards, alle paar Stunden für Preise und Listings und täglich oder wöchentlich für Richtlinien- und Dokumentationsseiten. Eine statische Seite jede Minute zu prüfen fügt Anfragekosten und Last hinzu, ohne die Erkennung zu verbessern, also wählen Sie das langsamste Intervall, das noch fängt, was Sie brauchen.

Bleiben Sie auch auf der richtigen Seite der Quelle. Verfolgen Sie nur öffentliche Seiten, diejenigen, die jeder ohne ein Konto laden kann, und lesen Sie die Nutzungsbedingungen und robots.txt der Site, bevor Sie einen wiederkehrenden Job auf sie richten; behandeln Sie beides als Grenze für das, was Sie sammeln. Halten Sie Ihr Anfragevolumen niedrig genug, damit Sie den Server nicht belasten, verteilen Sie Prüfungen über Ziele statt eine URL zu hämmern, und backen Sie ab, wenn Sie Fehler oder Herausforderungen sehen, anstatt es härter zu versuchen. Wenn eine Site eine offizielle API oder einen Change-Feed anbietet, bevorzugen Sie diese: es ist der Weg, den die Site dafür vorgesehen hat, und es ist in der Regel stabiler als das Parsen von HTML.

Häufig gestellte Fragen

Warum den Text mit einem Fingerabdruck versehen statt das rohe HTML zu vergleichen?

Rohes HTML ändert sich bei fast jeder Anfrage auf Weisen, die Sie nicht interessieren: Inline-Skripte, Ad-Slots, eingebettete Zeitstempel und CSRF-Tokens verschieben sich alle, während der eigentliche Inhalt gleich bleibt. Rohes HTML zu vergleichen gibt Ihnen bei fast jedem Lauf ein falsches Positiv. Die Seite zuerst auf lesbaren Text zu reduzieren und diesen dann zu hashen lässt den Fingerabdruck den Inhalt verfolgen, den Sie überwachen wollten, statt das Rauschen darum herum.

Funktioniert das auf JavaScript-lastigen Websites?

Ja, mit einer Änderung. Verwenden Sie einen JavaScript-Token mit der Crawling API statt des Standard-Tokens. Das rendert die vollständige Seite in einem echten Browser, bevor HTML zurückgegeben wird, sodass clientseitiger Inhalt vorhanden ist, wenn BeautifulSoup den Text extrahiert. Ohne ihn gibt eine clientseitig gerenderte Seite einen nahezu leeren Rahmen zurück und Ihr Fingerabdruck verfolgt den Rahmen statt des Inhalts.

Kann es mehrere Seiten gleichzeitig überwachen?

Ja. Übergeben Sie mehrere URLs in der Kommandozeile und das Skript verarbeitet sie der Reihe nach, wobei ein Fingerabdruck pro URL in der Snapshot-Datei gespeichert wird. Für große Listen rufen Sie parallel mit concurrent.futures.ThreadPoolExecutor ab, da die Arbeit I/O-gebunden ist, und erwägen Sie, den Speicher zu SQLite zu verschieben, damit der Zustand sauber skaliert.

Wie erhalte ich einen Alert, wenn sich etwas ändert?

Das Kernscript meldet Änderungen auf stdout, was ausreicht, wenn cron Ihnen seine Ausgabe per E-Mail sendet. Um einen echten Alert zu pushen, rufen Sie überall dort auf, wo check_for_change True zurückgibt: posten Sie zu einem Slack- oder Discord-Webhook, senden Sie eine E-Mail über eine Transaktions-API oder treffen Sie einen beliebigen HTTP-Endpunkt. Das sind ein paar Zeilen, die dem geänderten Zweig von run_once hinzugefügt werden.

Was ist die beste Speicheroption für das Verfolgen von Hunderten von URLs?

Ersetzen Sie die JSON-Dateien durch SQLite über das Standard-Bibliotheksmodul sqlite3. Es verarbeitet gleichzeitige Lesevorgänge, skaliert auf große URL-Listen und hält alle Zustände in einer portablen Datei. Nur die Lade- und Speicherfunktionen ändern sich; die Abruf-, Extraktions-, Fingerabdruck- und Vergleichslogik bleiben genau gleich.

Wie oft sollte der Tracker laufen?

Passen Sie das Intervall daran an, wie oft die Seite tatsächlich ändert. Schnell wechselnde Nachrichtenseiten und Dashboards rechtfertigen alle 15 bis 60 Minuten; Preis- und Produktlistings sind in der Regel mit einigen Stunden in Ordnung; Richtlinien- und Dokumentationsseiten können täglich oder wöchentlich geprüft werden. Viel öfter zu laufen als die Seite ändert fügt nur Anfragekosten und Last auf der Quelle hinzu, ohne etwas zu fangen, das Sie sonst verpassen würden.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.

NZ

Neil Zamora

Senior Architect · Crawlbase

Senior Architect bei Crawlbase mit Fokus auf den Systemen hinter großflächigem Crawling: Proxy-Rotation, Anti-Bot-Resilienz und den APIs, die diese Komplexität verbergen.