Das Auslesen von Daten aus dem modernen Web kann sich oft wie ein Versteckspiel anfühlen. Während vor einem Jahrzehnt die meisten Informationen im HTML-Format verfügbar waren, lieben Entwickler es heutzutage, Daten zu verbergen und zu verschleiern, indem sie sie dynamisch mit JavaScript rendern.
Für Schaber stellt dies eine interessante Herausforderung dar. Auch wenn wir uns nicht mehr darauf verlassen können, den rohen HTML-Inhalt zu analysieren, sind auf der Seite immer noch eine Fülle von Daten vorhanden – wir müssen nur wissen, wo wir suchen müssen.
In diesem umfassenden Leitfaden erkunden wir verschiedene Methoden, Tools und Techniken, die zum Extrahieren versteckter Webdaten verwendet werden können.
Was sind versteckte Webdaten?
Unter versteckten Webdaten versteht man alle Daten, die in der Roh-HTML-Quelle der Seite nicht direkt sichtbar sind. Das beinhaltet:
Daten werden nach dem Laden der Seite dynamisch über JavaScript geladen. Zum Beispiel das Rendern des Inhalts von a
<div>Tag durch Einfügen dynamisch erstellter HTML-Elemente.Daten, die in JavaScript-Variablen und darin eingebetteten Objekten gespeichert sind
<script>Stichworte. Häufig enthalten JSON-Objekte ganze Datensätze.HTML-Inhalt, der bei Benutzeraktion über AJAX-Anfragen generiert wird. Zum Beispiel das Erweitern von Kommentarthreads oder die unendliche Scroll-Paginierung.
Interne API-Anfragedaten und Metadaten, die vom Frontend für die Funktion verwendet werden. Zum Beispiel CSRF-Tokens, Benutzerinformationen, temporäre Caches.
Verschleierte und verschlüsselte Daten mit dem Ziel, Scraper am Zugriff darauf zu hindern.
Das gemeinsame Thema ist, dass diese Daten nicht im ursprünglichen, vom Server zurückgegebenen HTML-Code verfügbar sind, sondern später durch das auf der Seite ausgeführte JavaScript generiert werden.
Moderne dynamische Websites verlassen sich stark auf diese Technik, um schnelle Frontend-Erlebnisse zu erstellen. Alle Daten können ausgeblendet und bei Bedarf in kleinen Blöcken elegant gerendert werden.
Leider bedeutet dies, dass Scraper etwas härter arbeiten müssen, um an diese Daten zu gelangen. Schauen wir uns einige Möglichkeiten an, wie wir dies effizient tun können.
Versteckte Daten in HTML finden
Der erste Schritt besteht darin, zu bestätigen, ob die gewünschten Daten tatsächlich irgendwo im JavaScript der Seite versteckt sind.
Hier ist eine einfache Methode zur Überprüfung:
Laden Sie die Zielseite in den Browser und suchen Sie nach einer eindeutigen Datenkennung, die wir extrahieren möchten. Zum Beispiel ein Produktname oder eine Produkt-ID.
Deaktivieren Sie JavaScript im Browser und laden Sie die Seite neu. Dies kann in den Entwicklertools erfolgen.
Überprüfen Sie, ob die eindeutige Kennung noch im rohen HTML-Quellcode vorhanden ist.
Wenn die Daten verschwunden sind, werden sie höchstwahrscheinlich beim Laden der Seite dynamisch von JavaScript gerendert.
Jetzt müssen wir die HTML-Quelle durchsuchen, um herauszufinden, wo und wie sie diesen Inhalt generiert.
Extrahieren von Daten aus Tags
Einer der häufigsten Orte, an denen sich versteckte Daten befinden, ist das Innere <script> Stichworte.
Dies können JSON-Objekte, JavaScript-Variablen, ganze Datensätze oder Code sein, der die Seite manipuliert.
Beispielsweise:
<html>
<body>
<div id="product"></div>
<script>
// product data as javascript object
var data = {
"product": {
"name": "Super Product",
"price": 99.99
}
}
// data rendered on page load
document.getElementById("product").innerHTML = data.product.name + ": £" + data.product.price;
</script>
</body>
</html>Hier werden die eigentlichen Produktdaten in einer JavaScript-Objektvariablen namens gespeichert data.
Das Produkt <div> ist zunächst leer und wird beim Laden der Seite dynamisch gefüllt.
Um diese Daten zu extrahieren, müssen wir zunächst die relevanten Daten finden <script> Tag im Roh-HTML. Dies kann mit jeder HTML-Parsing-Bibliothek wie BeautifulSoup oder Parsel erfolgen:
# extract scripts from HTML with BeautifulSoup
from bs4 import BeautifulSoup
html = # page HTML
soup = BeautifulSoup(html, ‘html.parser‘)
scripts = soup.find_all(‘script‘)Als nächstes müssen wir die Daten gezielt aus dem Skriptinhalt extrahieren.
Methode 1: Als JSON laden
Wenn es sich bei den Daten um ein gültiges JSON-Objekt handelt, können wir sie einfach direkt mit Python laden json Modul:
import json
# find script with data variable
script = soup.find(‘script‘, text=lambda t: ‘data =‘ in t)
# load json directly
data = json.loads(script.string)
print(data[‘product‘])
# {‘name‘: ‘Super Product‘, ‘price‘: 99.99}Dies funktioniert hervorragend, wenn das Skript-Tag dies angibt type="application/json".
Methode 2: Regex-Matching
Für komplexere Daten müssen wir den rohen JavaScript-Code selbst analysieren. Hier kommen reguläre Ausdrücke zum Einsatz.
Wir können den Code scannen und Teile extrahieren, die einem Muster entsprechen – wie zum Beispiel unser Datenobjekt.
import re
import json
script = soup.find(‘script‘, text=lambda t: ‘data =‘ in t)
# match the data object by surrounding syntax
match = re.search(r‘data = ({.+})‘, script.string)
# load matched json
data = json.loads(match.group(1))
print(data[‘product‘])
# {‘name‘: ‘Super Product‘, ‘price‘: 99.99}Der Schlüssel liegt darin, sorgfältig ein Regex-Muster zu erstellen, das den gewünschten Datensatz eindeutig vom Rest des Codes identifiziert.
Methode 3: JavaScript-Parsing
Für erweitertes Scraping möchten wir möglicherweise den gesamten JavaScript-Code analysieren – einschließlich Variablen, Funktionen und Objekten.
Dies ermöglicht die Extraktion beliebiger Daten unter Beibehaltung der ursprünglichen Struktur und des ursprünglichen Kontexts.
Wir können Bibliotheken wie verwenden PyJavascript und Js2Py um JavaScript in Python zu interpretieren.
Zum Beispiel mit PyJavascript:
import javascript
script = soup.find(‘script‘, text=lambda t: ‘data =‘ in t)
# init JavaScript interpreter
js = javascript.Interpreter()
# run script to define data variable
js.execute(script.string)
# access parsed data object
print(js.context[‘data‘][‘product‘])
# {‘name‘: ‘Super Product‘, ‘price‘: 99.99} Dadurch können wir auf die gesamte JavaScript-Umgebung zugreifen und nicht nur auf die gewünschten Datensätze zugreifen.
Scraping von API-Daten aus JavaScript
APIs steuern den Großteil des dynamischen Verhaltens auf modernen Websites. JavaScript stellt Anfragen zum Laden von Daten, zum Senden von Formularen oder zum Auslösen von Interaktionen.
Indem wir uns mit dem Seitencode befassen, können wir diese API-Endpunkte finden und die Anforderungen zum Extrahieren von Daten nachahmen.
Hier ist zum Beispiel ein einfaches Skript, das Produktdaten von a lädt /api/products/123 Endpunkt:
async function loadProduct(){
let response = await fetch(‘/api/products/123‘);
let product = await response.json();
// render product data to page
document.getElementById("product").innerHTML = product.name;
}
loadProduct();Sobald wir dieses Skript im HTML gefunden haben, können wir:
Extrahieren Sie die API-URL aus dem
fetch()rufen Sie uns an!Analysieren Sie die AJAX-Anfrage- und Antwortformate
Replizieren Sie die API-Anfrage direkt in Python mit Bibliotheken wie Requests
Dies ermöglicht das Scrapen von Daten aus APIs, auf die JavaScript angewiesen ist, ohne dass Browsercode ausgeführt werden muss.
Suchen von Daten in JavaScript-Variablen
Seitendaten werden üblicherweise auch direkt in JavaScript-Variablen gespeichert.
Beispielsweise:
// javascript data
var products = [
{name: "Product 1", price: 19.99},
{name: "Product 2", price: 24.99}
];
function renderProducts(){
// loop through products and render HTML
} Hier wird die vollständige Produktliste in einer Variablen namens gespeichert products.
Um dies zu extrahieren, müssen wir zunächst den Variablennamen finden, der zu unserer Zieldatenstruktur passt. Wir können einen ähnlichen Regex-Ansatz verwenden:
import re
import json
# find products variable
script = soup.find(‘script‘, text=lambda t: ‘var products =‘ in t)
# match products json
match = re.search(r‘var products = ({.+});‘, script.string)
data = json.loads(match.group(1))
print(data)
# [{name: "Product 1", price: 19.99}, {name: "Product 2", price: 24.99}]Wenn die Datenstruktur komplexer ist, können wir die gesamte JavaScript-Umgebung analysieren, um auf alle Variablen im Gültigkeitsbereich zuzugreifen.
Scraping-Inhalte, die über AJAX geladen wurden
Websites laden Inhalte nach dem Laden der Seite häufig dynamisch über AJAX.
Zum Beispiel erweiternde Kommentarthreads, unendliche Scroll-Paginierung oder Tabulatoren.
Dieser Inhalt ist im ursprünglichen HTML-Code nicht vorhanden, wird jedoch bei Bedarf vom Server angefordert.
Wir können diese AJAX-Schnipsel entfernen, indem wir:
Überwachen Sie Netzwerkanfragen auf der Seite, um AJAX-URLs zu identifizieren.
AJAX-Anfragen rekonstruieren und direkt aus Python-Code senden.
Parsen der AJAX-Antworten, die HTML/JSON-Daten enthalten.
Betrachten Sie beispielsweise dieses Skript, das paginierte Daten beim Scrollen lädt:
// initially loaded page data
var results = [ /* initial page of data */];
// paginate on scroll
window.addEventListener(‘scroll‘, function() {
var page = results.length / 20 + 1;
// request next page
fetch(‘/data?page=‘ + page)
.then(res => res.json())
.then(data => {
results.push(...data);
// render new data
});
});Hier können wir sehen, dass Seiten von angefordert werden /data Endpunkt und Anhängen von Inhalten an results variabel.
Wir können diese Anfragen replizieren und die Daten direkt extrahieren, ohne den gesamten gerenderten HTML-Code analysieren zu müssen.
Ausführen von JavaScript mit Headless-Browsern
Für das ultimative dynamische Content-Scraping können wir einen vollständigen Headless-Browser starten, die Seite laden und direkt auf die JavaScript-Umgebung zugreifen.
Dies ermöglicht die Auswertung von Code, das Laden dynamischer Inhalte und den Zugriff auf alle Daten, Funktionen oder DOM-Elemente, die auf der Live-Seite verfügbar sind.
Hier ist ein Beispiel mit Playwright in Python:
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch()
page = browser.new_page()
page.goto(‘https://targetpage.com‘)
# evaluate browser context to get data
data = page.evaluate(‘window.products‘)
browser.close()
print(data)Der Schlüssel wird verwendet page.evaluate() um benutzerdefinierten JavaScript-Code im Kontext der geladenen Seite auszuführen.
Dies gibt uns vollständigen Zugriff auf alle ansonsten verborgenen Daten.
Der Nachteil besteht darin, dass eine vollständige Browserinstanz gestartet werden muss – was langsamer ist als direkte HTTP-Anfragen. Daher sollte diese Methode bei komplexen Seiten sparsam eingesetzt werden.
Verschleierte und verschlüsselte Daten
Websites verschleiern ihr JavaScript häufig absichtlich, um Scraping zu verhindern.
Einige Beispiele:
Reduzieren von Variablen- und Funktionsnamen auf bedeutungslose Zeichen wie z
a,b,fn1()Aufteilen von Datensätzen auf mehrere Variablen und Skripte
Verschlüsseln/Kodieren von Daten, sodass sie nicht für Menschen lesbar sind
Dynamisches Zusammensetzen von Daten zur Laufzeit aus fragmentierten Teilen
Codeschutztechniken wie Packen, Verschleierung, Anti-Debugging und VM-Ausführung
Dies kann das Parsen des JavaScript sehr schwierig machen. Kleine Codeänderungen können unsere Scraper leicht kaputt machen.
Es gibt verschiedene Möglichkeiten, mit stark verschleierten Seiten umzugehen:
Verwenden Sie Headless-Browser wie Playwright oder Puppeteer, um ausgeführten Code zu laden, anstatt die verschleierte Quelle direkt zu analysieren.
Verfolgen Sie die Codeausführung, um zu verstehen, wie Daten zusammengestellt werden – zum Beispiel mithilfe von Browser-Entwicklertools oder der Proxy-Weiterleitung des Browser-Datenverkehrs.
Analysieren Sie, wie echte Benutzer mit der Seite interagieren, um Datenquellen zu identifizieren.
Mustervergleiche bekannte Datenstrukturen – wie Produktnamen, Preise, IDs – um relevante Codeteile zu finden, auch wenn Variablen verschleiert sind.
Versuchen Sie für die Verschlüsselung, Verschlüsselungsschlüssel zu finden oder Entschlüsselungsalgorithmen zurückzuentwickeln.
Mit der Zeit können wir Resilienz aufbauen, indem wir Scraper weiterentwickeln, um sie an Verschleierungsänderungen anzupassen.
Scraping versteckter APIs mit Proxys
Versteckte Web-APIs verwenden häufig fortschrittliche Anti-Scraping-Techniken wie IP-Ratenbegrenzung, Captcha und Bot-Erkennung, um den Zugriff zu verhindern.
Hier sind Proxys beim Scraping sehr praktisch. Indem wir Anfragen über private IPs weiterleiten, können wir viele Schutzmaßnahmen umgehen und in großem Umfang auf APIs zugreifen.
Einige Tipps zum Scrapen mit Proxys:
Verwenden Sie eine regelmäßige Proxy-Rotation, um zu verhindern, dass bestimmte IPs blockiert werden
Aktivieren Sie die Proxy-Rotation basierend auf Regionen oder ISPs für eine große Vielfalt
Verwenden Sie Backconnect-Proxys, die Tausende eindeutiger IP-Adressen zum Durchlaufen bereitstellen
Begrenzen Sie die Anfrageraten pro Proxy, um das reale Benutzerverhalten nachzuahmen
Nutzen Sie die Proxy-Autorisierung, um sich als echte Geräte auszugeben, nicht nur als anonyme IPs
Überwachen und behandeln Sie häufige Blockaden wie Captchas, blockierende Seiten und 429-Fehler
Mit der richtigen Proxy-Einrichtung können wir auf praktisch jede Zielseite oder versteckte API zugreifen.
Scraping-Dienste für versteckte Daten
Es gibt auch verwaltete Scraping-Dienste, die speziell zum Extrahieren von JavaScript-gerenderten Daten entwickelt wurden.
Diese bieten Browser-Automatisierung, Proxy-Verwaltung und JavaScript-Ausführungsfunktionen.
Einige Beispiele:
SchabenBiene – Browser- und Proxy-API, die JS in Seiten auswerten kann.
SchaberAPI – Headless-Browser-API mit automatischer Proxy-Rotation.
Apify – Actor-Laufzeit für Browser-Automatisierung im großen Maßstab.
ScrapeOps – Visueller Browser-Automatisierungs-Builder mit JS-Extraktion.
ScrapFly – Nicht blockierbare Scraping-API mit Millionen von Backconnect-Proxys für Privathaushalte.
Diese Dienste bewältigen alle Komplexitäten des dynamischen Seitenrenderings und erleichtern das Scrapen verborgener Daten.
Key Take Away
Hier sind die wichtigsten Punkte zum Scrapen versteckter Website-Daten:
Überprüfen Sie Seiten ohne JavaScript, um sicherzustellen, dass die Daten dynamisch geladen werden
Extrahieren und analysieren Sie Skripte, Variablen und JSON-Objekte aus HTML
Analysieren und replizieren Sie AJAX-Anfragen, um auf versteckte APIs zuzugreifen
Verwenden Sie bei Bedarf Proxys und Headless-Browser für umfangreiche JS-Sites
Mustervergleich und Reverse Engineering von verschleiertem Code
Passen Sie Scraper an den Anti-Bot-Schutz an
Mit den richtigen Techniken können praktisch alle öffentlichen Website-Daten extrahiert werden. Wir müssen nur wissen, wo wir suchen müssen!
