In einem Satz: Dieses Tutorial zeigt Ihnen, wie Sie ein Python-Skript zur Website-Überwachung erstellen, das Seiten über … abruft. Crawlbase, generiert SHA-256-Inhaltsfingerabdrücke und benachrichtigt Sie bei Änderungen; keine Proxy-Infrastruktur erforderlich.

Um einen Änderungstracker für eine Website zu erstellen, ist der einfachste Ansatz der Vergleich mit einer früheren Version. Ein Skript ruft die Seite ab, extrahiert den relevanten Text und generiert daraus einen Fingerabdruck. Beim nächsten Ausführen wiederholt es diese Schritte und prüft, ob der Fingerabdruck noch übereinstimmt. Stimmt er nicht überein, hat sich etwas auf der Seite geändert.

In diesem Tutorial erstellen wir ein Python-Skript, das diesen Workflow abwickelt. Es ruft den HTML-Code der Seite über die Crawlbase Crawling APIDas Skript extrahiert den lesbaren Text der Seite und generiert einen SHA-256-Hash des bereinigten Inhalts. Dieser Hash wird lokal gespeichert, sodass das Skript ihn beim nächsten Seitenaufruf vergleichen kann.

Am Ende verfügen Sie über einen funktionierenden Änderungstracker, der eine oder mehrere URLs überwachen, Momentaufnahmen speichern, strukturierte Ergebnisse ausgeben und automatisch nach einem Zeitplan ausgeführt werden kann.

Wie die Änderungsverfolgung auf Websites funktioniert

Die Änderungsverfolgung auf Websites folgt einem wiederholbaren sechsstufigen Prozess, der den Rohdateninhalt der Seite in ein vergleichbares Signal umwandelt.

  • Schritt 1 – Seiteninhalt abrufen. Rufen Sie den vollständigen HTML-Code der Ziel-URL ab. Verwenden Sie dazu eine zuverlässige API wie z. B. Crawlbase Vermeidet Blockaden und stellt sicher, dass JavaScript-gerenderte Inhalte eingebunden werden.
  • Schritt 2 — Extrahieren Sie den Teil der Seite, den Sie überwachen möchten. Entfernen Sie Navigation, Skripte, Fußzeilen und Werbung. Sie benötigen nur den relevanten Fließtext.
  • Schritt 3 – Normalisieren Sie den Text. Leerzeichen reduzieren, Formatierungsartefakte entfernen und die Kodierung standardisieren, damit kosmetische Änderungen keine Fehlalarme auslösen.
  • Schritt 4 – Generieren Sie einen Inhaltsfingerabdruck. Ein Inhaltsfingerabdruck ist ein kryptografischer Hash fester Länge (in diesem Tutorial SHA-256), der aus dem bereinigten Seitentext abgeleitet wird. Schon die Änderung eines einzigen Wortes erzeugt einen völlig anderen Hash, wodurch Fingerabdrücke eine schnelle und speichereffiziente Methode zur Erkennung von Aktualisierungen darstellen.
  • Schritt 5 — Vergleichen Sie mit dem gespeicherten Fingerabdruck. Laden Sie den beim letzten Durchlauf gespeicherten Fingerabdruck und vergleichen Sie ihn mit dem soeben generierten. Wenn sie sich unterscheiden, hat sich die Seite geändert.
  • Schritt 6 — Ergebnis aufzeichnen oder melden. Speichern Sie den neuen Fingerabdruck für den nächsten Durchlauf und geben Sie optional eine Differenz aus, die genau anzeigt, was sich geändert hat.

Die größte Herausforderung besteht darin, Fehlalarme zu vermeiden. Roh-HTML enthält oft Elemente, die sich häufig ändern, wie Skripte, Werbung, Zeitstempel oder dynamische Widgets. Der Vergleich von bereinigtem Text anstelle von Roh-HTML liefert genauere Ergebnisse.

Warum verwenden Crawlbase für Seitenverfolgung

Sie könnten ein Tracking-Skript erstellen mit direkte HTTP-AnfragenViele Websites blockieren oder drosseln jedoch automatisierte Anfragen. Einige Seiten basieren zudem stark auf JavaScript, sodass der von einer Standardanfrage zurückgegebene HTML-Code möglicherweise nicht den eigentlichen Inhalt enthält.

Crawlbase löst diese Probleme, indem es das Abrufen von Seiten für Sie übernimmt.

Zu den wichtigsten Vorteilen gehören:

  • Zuverlässiger Seitenaufruf auf einer Vielzahl von Websites
  • Eingebaute Handhabung zum Blockieren, Drosseln und für CAPTCHAs
  • JavaScript-Rendering über das JS-Token,
  • Keine Proxy-Infrastruktur verwalten oder pflegen

Konsistente HTML-Ausgabe das eignet sich für wiederholbare Vergleiche

Ihr Überwachungsskript konzentriert sich ausschließlich auf das Extrahieren und Vergleichen von Inhalten, während Crawlbase fungiert als Abrufschicht.

Voraussetzungen und technische Anforderungen

Bevor Sie beginnen, stellen Sie sicher, dass Ihre Umgebung Folgendes beinhaltet.

Umgebungsanforderungen:

AnforderungDetail
PythonVersion 3.10 oder höher
Crawlbase API-TokenDas kostenlose Paket beinhaltet 1,000 Anfragen.
BetriebssystemLinux, macOS oder Windows

Das Tutorial verwendet folgende Python-Pakete:

VerpackungZweck
ZugriffeHTTP-Anfragen an die Crawlbase API
schönesuppe4HTML-Parsing und Textextraktion
HashlibSHA-256-Fingerabdruckerzeugung
JSONLokaler Snapshot-Speicher
difflibGenerieren von für Menschen lesbaren Differenzen

Schritt 1: Abhängigkeiten installieren

Aus dem Projektverzeichnis herunterladen requirements.txtund führen Sie Folgendes aus:

1
pip install -r Anforderungen.txt

Dadurch werden Abhängigkeiten wie requests (v2.28.0) und beautifulsoup4 (v4.11.0) installiert.

Schritt 2: Eine Webseite abrufen mit Crawlbase

Im nächsten Schritt wird überprüft, ob der HTML-Code der Seite erfolgreich abgerufen werden kann.

Das Skript sendet eine Anfrage an die Crawlbase Crawling API und gibt den Antwortinhalt zurück.

Den vollständigen Codebeispiel finden Sie auf ScraperHub - fetch.py

1
2
3
4
5
6
7
8
def Seite abrufen(url: str, Token: str | Keine Präsentation = Keine Präsentation) -> str:
    api_token = Token or os.environ.get("CRAWLBASE_TOKEN", "")
    if kein Frontalunterricht. api_token:
        erhöhen WertFehler("Crawlbase Token erforderlich: Setzen Sie CRAWLBASE_TOKEN oder übergeben Sie ein Token=")
    api_url = f"{CRAWLBASE_API_URL}/?token={api_token}&url={quote(url)}"
    Antwort = requests.get(api_url, timeout=30)
    Response.raise_for_status()
    Rückkehr Antworttext

Diese Funktion:

• Liest die Crawlbase Zeichen
• Sendet die Ziel-URL an die Crawling API
• Ruft den HTML-Code der Seite ab
• Gibt den Inhalt zur Verarbeitung zurück.

Die Verwendung von Crawlbase stellt sicher, dass das Überwachungs- und Tracking-Tool eine zuverlässige HTML-Ausgabe erhält.

Schritt 3: Extrahieren der zu verfolgenden Inhalte

Der Vergleich von reinem HTML-Code ist unzuverlässig, da Seiten viele Elemente enthalten, die sich häufig ändern.

Um Störungen zu reduzieren, extrahiert das Skript lesbaren Seitentext und entfernt unnötige Elemente.

Codebeispiel auf ScraperHub - extract.py

1
2
3
4
5
6
def extrahierbaren_Text(html: str) -> str:
    Suppe = Schöne Suppe (html, "html.parser")
    für  Etikett in Suppe(["Skript", "Stil", "nav", "Fußzeile"]):
        tag.decompose()
    text = soup.get_text(separator="", strip=richtig)
    Rückkehr "".join(text.split())

Diese Funktion führt mehrere Schritte aus:

• Entfernt Skripte und Stile
• Entfernt Navigations- und Fußzeilenelemente
• Extrahiert lesbaren Text
• Normalisiert Leerzeichen

Das Ergebnis ist eine einheitliche Textdarstellung des Seiteninhalts.

Schritt 4: Erstellen Sie einen Inhaltsfingerabdruck

Anstatt vollständige Seitenaufnahmen zu speichern, generiert das Tool einen Fingerabdruck mithilfe eines kryptografischen Hashwerts.

Ein Hashwert wandelt Text in eine Zeichenkette fester Länge um. Ändert sich der Inhalt, ändert sich auch der Hashwert.

Beispiel (fingerprint.py):

1
2
def Inhaltsfingerabdruck(Text: str) -> str:
    Rückkehr hashlib.sha256(text.encode("utf-8")).hexdigest()

Dies schafft ein SHA-256-Fingerabdruck des bereinigten Textes.

Vorteile der Verwendung von Hashes:

• Schneller Vergleich
• Minimaler Speicherbedarf
• Zuverlässige Erkennung kleiner Änderungen

Bereits eine kleine Änderung am Text führt zu einem anderen Hashwert.

Schritt 5: Vorherige Snapshots speichern

Um Aktualisierungen zu erkennen, muss sich das Tool die Fingerabdrücke vorheriger Ausführungen merken.

Dadurch werden zwei Snapshot-Dateien gespeichert:

  • snapshots.json - Speichert URL → Fingerprint-Zuordnungen.

  • snapshots_text.json - Speichert den normalisierten Text für jede Seite, sodass Unterschiede bei Inhaltsänderungen angezeigt werden können.

Beispiel (storage.py):

1
2
3
4
5
6
7
8
9
10
def Snapshots laden(Pfad: str | Pfad) -> diktieren[str, str]:
    p = Pfad(Pfad)
    if kein Frontalunterricht. p.exists():
        Rückkehr {}
    und  XNUMXh geöffnet(p, encoding=“utf-8") as f:
        Rückkehr json.load(f)

def Schnappschüsse speichern(Momentaufnahmen: diktieren[str, str], Weg: str | Pfad) -> Keine Präsentation:
    und  XNUMXh geöffnet(path, “w”, encoding=“utf-8") as f:
        json.dump(snapshots, f, indent=2)

Wenn der Monitor wieder läuft, lädt er die gespeicherten Fingerabdrücke und vergleicht sie mit den neu generierten.

Schritt 6: Vergleich der aktuellen mit der vorherigen Version

Sobald der aktuelle Fingerabdruck generiert ist, vergleicht das Skript ihn mit dem gespeicherten Fingerabdruck.

Beispiel (monitor.py):

1
2
3
4
5
def Änderungsprüfung(url: str, current_hash: str, Momentaufnahmen: diktieren[str, str]) -> bool:
    vorherige = snapshots.get(url)
    if früher is Keine Präsentation:
        Rückkehr richtig
    Rückkehr vorheriger Hash != aktueller Hash

Wenn die Fingerabdrücke unterschiedlich sind, meldet das Skript eine Änderung.

Mögliche Ergebnisse:

Geändert
Keine Änderung

Beim ersten Überprüfen einer URL meldet das Skript immer Folgendes: Geändert Da noch keine vorherige Momentaufnahme existiert, werden der aktuelle Fingerabdruck und der Seitentext für zukünftige Vergleiche gespeichert.

Wenn sich der Seiteninhalt ändert, generiert das Tool auch eine Unified Diff zeigt an, was sich geändert hat. Eine Beispielausgabe könnte so aussehen:

1
2
3
4
--- vorherige
+++ Strom
- Alter Satz
+ Neuer Satz

Dieser Diff wurde mit Python generiert. difflib Das Modul hilft dabei, genau zu identifizieren, was sich zwischen den Seitenversionen geändert hat.

Schritt 7: Aktualisierten Snapshot speichern

Nach der Überprüfung auf Änderungen aktualisiert das Skript den gespeicherten Snapshot, sodass zukünftige Ausführungen neue Aktualisierungen erkennen können.

In monitor.pyDas Skript speichert sowohl den Fingerabdruck als auch den extrahierten Text.

1
2
3
4
snapshots[url] = Fingerabdruck
snapshot_texts[url] = text
save_snapshots(snapshots, path)
save_snapshot_texts(snapshot_texts, path)

Durch das Speichern beider Werte kann das Tool zukünftige Änderungen erkennen und lesbare Differenzen generieren.

Schritt 8: Den Monitor zeitgesteuert ausführen

Überwachungstools sind am nützlichsten, wenn sie automatisch laufen.

Es stehen verschiedene Terminplanungsoptionen zur Verfügung, darunter gängige Ansätze wie:

  • Cron-Jobs unter Linux oder macOS
  • Windows Task Scheduler
  • Cloudbasierte Jobplaner

Dieses Tool unterstützt auch die integrierte Intervallplanung.

Beispielhafte CLI-Konfiguration in main.py:

1
2
3
4
5
6
7
8
parser.add_argument("--Intervall", tippe=schweben, Metavariable="SEKUNDEN",
    Hilfe=„Kontinuierlich ausführen: Alle URLs werden alle SEKUNDEN erneut geprüft (z. B. 3600 für stündlich). Strg+C zum Beenden.“)
#...
und gleichzeitig die richtig:
    results = run_once(args.url, args.snapshots, args.json)
    if args.interval is Keine Präsentation:
        brechen
    time.sleep(args.interval)

Beispielverwendung:

1
python main.py https://example.com --interval 3600

Vollständiges, lauffähiges Skript

Die vollständige Implementierung vereint alle Komponenten zu einem modularen Überwachungs- und Tracking-Tool.

ScraperHub-Repository Layout:

Reichen Sie dasFunktion / Rolle (Role) *
fetch.pyHTML abrufen mit Crawlbase
extract.pyBereinigen Sie den HTML-Code und normalisieren Sie den Text.
fingerprint.pyGenerieren Sie einen SHA-256-Fingerabdruck.
storage.pySnapshot-Daten laden und speichern
monitor.pyVergleiche Momentaufnahmen und erkenne Änderungen
main.pyCLI-Einstiegspunkt und Scheduler

So führen Sie das Skript aus

Setze deine Crawlbase Token zuerst.

1
exportieren CRAWLBASE_TOKEN="your_token"

Führen Sie anschließend das Skript aus.

1
Python main.py https://targeturl.com

Um mehrere Seiten zu überwachen:

1
python main.py https://targeturl1.com https://targeturl2.com ...

Der erste Durchlauf meldet immer Geändertda noch kein Snapshot existiert.

Strategien zur Fehlerbehandlung

Ein produktives Python-Webseitenüberwachungsskript muss drei häufige Fehlermodi elegant abfangen können.

  • Netzwerk-Timeouts: Die requests.get(timeout=30) Anruferhöhungen requests.exceptions.Timeout wenn die Crawlbase Die API antwortet nicht innerhalb von 30 Sekunden. Schließen Sie die Fetch-Aufrufe in einen try/except-Block ein und implementieren Sie einen exponentiellen Backoff für Wiederholungsversuche.
1
2
3
4
5
6
7
8
9
10
importieren Zeit
​def fetch_with_retry(url: str, Token: str, Wiederholungsversuche: int = 3, zurückweichen: schweben = 2.0) -> str:
    für  Versuch in Angebot(Wiederholungsversuche):
        versuchen:
            Rückkehr fetch_page(url, token)
        ausgeschlossen requests.exceptions.Timeout:
            if Versuch < Wiederholungen - 1:
                time.sleep(backoff ** attempt)
            sonst:
                erhöhen

​

  • HTTP-Fehler: response.raise_for_status() 4xx/5xx-Antworten werden als Ausnahmen behandelt. Der Statuscode und die URL werden protokolliert, und die betroffene URL wird übersprungen, anstatt den gesamten Lauf abzubrechen.
  • Fehlerhaftes HTML: BeautifulSoup verarbeitet die meisten fehlerhaften HTML-Codes problemlos, aber extrem fehlerhafte Seiten können leeren Text erzeugen. Fügen Sie nach der Extraktion eine Prüfung hinzu: wenn extract_monitorable_text() Gibt eine leere Zeichenkette zurück, überspringt den Fingerabdruckvergleich und protokolliert eine Warnung, anstatt eine fehlerhafte Änderung aufzuzeichnen.

Skalierung des Tools für mehrere URLs

Das Tutorial konzentriert sich auf eine minimale Implementierung, das System kann jedoch für größere Überwachungsaufgaben erweitert werden.

Mögliche Verbesserungen umfassen:

• Gleichzeitiges Verfolgen mehrerer Seiten
• Parallele Anfrageverarbeitung
• Verwendung von Datenbanken anstelle von JSON-Speicherung
• Hinzufügen von strukturierter Protokollierung und Wiederholungsversuchen

Durch diese Änderungen wird das System robuster für Produktionsumgebungen.

Einschränkungen und bewährte Methoden

Ein einfacher Änderungstracker funktioniert gut für viele Seiten, aber auf echten Websites können einige Komplikationen auftreten.

Dynamischer Inhalt

Manche Websites laden Inhalte per JavaScript erst nach dem ersten Seitenaufruf. Wenn der Teil der Seite, den Sie verfolgen möchten, auf diese Weise generiert wird, … Crawlbase Die Anfrage liefert möglicherweise nicht den vollständigen Inhalt. Wechseln Sie in diesem Fall zu … Crawlbase JavaScript-Token Die Seite wird also gerendert, bevor der HTML-Code zurückgegeben wird.

Authentifizierung

Für Seiten, die eine Anmeldung erfordern, muss die Anfrage gültige Session-Cookies enthalten.

Fix: Authentifizierte Cookies über die Crawlbase Cookies Parameter, damit der Crawler auf die eingeloggte Version der Seite zugreift.

Ratenlimits

  • Standardlimit: 20 Anfragen pro Sekunde
  • Für die meisten Überwachungsaufgaben ist dies ausreichend.
  • Kontakt Crawlbase Unterstützung eine höhere Obergrenze für Großaufträge beantragen

Überwachungsintervalle

Wählen Sie die Prüfhäufigkeit basierend darauf, wie oft sich die Seite tatsächlich ändert:

  • Nachrichtenseiten/Dashboards: alle 15–60 Minuten
  • Produktlisten/Preise: alle 1-6 Stunden
  • Richtlinienseiten/Dokumentation: täglich oder wöchentlich

Zu häufige Prüfungen erhöhen die Anfragekosten, ohne die Erkennungsgenauigkeit zu verbessern.

Was kommt als nächstes

Mit dem Skript aus dieser Anleitung verfügen Sie bereits über einen funktionierenden Website-Änderungstracker, der mit Python erstellt wurde. CrawlbaseVon hier aus können Sie es je nach Bedarf erweitern. Beispielsweise können Sie Benachrichtigungen hinzufügen, Ergebnisse in einer Datenbank speichern oder eine größere Liste von URLs parallel überwachen.

Wenn Sie es selbst ausprobieren möchten, erstellen Sie ein Crawlbase Erstelle ein Konto und nutze die 1,000 kostenlosen Anfragen. um den Tracker zu testen und sofort mit der Überwachung und dem Tracking von Seiten zu beginnen.

Häufig gestellte Fragen

Kann dies mehrere Seiten gleichzeitig überwachen?

Ja. Mehrere URLs können an die Befehlszeile übergeben werden: python main.py https://site1.com https://site2.comDas Skript verarbeitet sie standardmäßig nacheinander; aktivieren Sie die parallele Verarbeitung mit ThreadPoolExecutor für schnellere Durchläufe großer URL-Listen.

Wie oft sollten die Prüfungen durchgeführt werden?

Es hängt davon ab, wie häufig sich die Inhalte ändern. Stündliche Überprüfungen sind für die meisten Anwendungsfälle ein sinnvoller Standardwert. Seiten mit hoher Aktualisierungsfrequenz (Live-Ergebnisse, Eilmeldungen) sollten alle 10–15 Minuten überprüft werden. Statische Dokumentationsseiten können täglich überprüft werden.

Funktioniert es auch auf Webseiten mit hohem JavaScript-Anteil?

Ja, mit einer Konfigurationsänderung. Verwenden Sie die Crawlbase JavaScript-Token anstelle des Standard-Tokens. Dadurch wird die gesamte Seite in einem Headless-Browser gerendert, bevor HTML zurückgegeben wird, wodurch sichergestellt wird, dass dynamische Inhalte erfasst werden.

Kann es Benachrichtigungen senden, wenn sich etwas ändert?

Das Kernskript gibt Änderungen an die Standardausgabe (stdout) und optional in eine JSON-Datei aus. Für die Integration von Benachrichtigungen ist eine kleine Erweiterung erforderlich – beispielsweise der Aufruf einer E-Mail-API (z. B. SendGrid), das Senden einer Nachricht an einen Slack-Webhook oder das Auslösen eines beliebigen HTTP-Endpunkts. check_for_change() Rückgabe True.

Welche Speicheroption eignet sich am besten für die Verwaltung von Hunderten von URLs?

Ersetzen Sie die standardmäßigen JSON-Dateien durch SQLite-Dateien mithilfe von sqlite3 Standardbibliotheksmodul. Es verarbeitet gleichzeitige Lesevorgänge, skaliert auf große URL-Listen und speichert den gesamten Zustand in einer einzigen portablen Datei. Eine sofort einsatzbereite Implementierung finden Sie im Abschnitt „Skalierung“ weiter oben.