Web-Scraping mit Scrapy Splash im Jahr 2025

In dieser Anleitung zu Scrapy Splash lernen Sie:

Was Scrapy Splash ist
Schritt-für-Schritt-Tutorial zur Verwendung von Scrapy Splash in Python
Erweiterte Scraping-Techniken mit Splash in Scrapy
Einschränkungen beim Scrapen von Websites mit diesem Tool

Lasst uns eintauchen!

Was ist Scrapy Splash?

Scrapy Splash bezieht sich auf die Integration zwischen diesen beiden Tools:

Scrapy: Eine Open-Source-Crawling-Framework-Bibliothek in Python zum Extrahieren der benötigten Daten aus Websites.
Splash: Ein leichtgewichtiger Headless-Browser, der für die Darstellung von JavaScript-lastigen Webseiten entwickelt wurde.

Sie fragen sich vielleicht, warum ein leistungsfähiges Tool wie Scrapy Splash braucht. Nun, Scrapy kann nur statische Websites verarbeiten, da es auf HTML-Parsing-Fähigkeiten (insbesondere von Parsel) angewiesen ist. Beim Scraping dynamischer Websites müssen Sie sich jedoch mit dem Rendering von JavaScript befassen. Eine gängige Lösung ist die Verwendung eines automatisierten Browsers, was genau das ist, was Splash bietet.

Mit Scrapy Splash können Sie eine spezielle Anfrage – bekannt als SplashRequest - aneinen Splash-Server senden. Dieser Server rendert die Seite vollständig, indem er JavaScript ausführt, und gibt das verarbeitete HTML zurück. So kann Ihr Scrapy Spider Daten von dynamischen Seiten abrufen.

Kurz gesagt, Sie brauchen Scrapy Splash, wenn:

Sie arbeiten mit JavaScript-lastigen Websites, die Scrapy allein nicht scrapen kann.
Sie bevorzugen eine leichtgewichtige Lösung im Vergleich zu Selenium oder Playwright.
Sie möchten den Overhead vermeiden, der durch die Ausführung eines vollständigen Browsers für das Scraping entsteht.

Wenn Scrapy Splash Ihre Anforderungen nicht erfüllt, sollten Sie diese Alternativen in Betracht ziehen:

Selenium: Eine vollwertige Browser-Automatisierungsfunktion für das Scraping von JavaScript-lastigen Websites, die interessante Erweiterungen wie Selenium Wire bietet.
Playwright: Ein Open-Source-Browser-Automatisierungstool, das eine konsistente, browserübergreifende Automatisierung und eine robuste API bietet, die mehrere Programmiersprachen unterstützt.
Puppeteer: Eine Open-Source-Node.js-Bibliothek, die eine High-Level-API für die Automatisierung und Steuerung von Chrome über das DevTools-Protokoll bietet.

Scrapy Splash in Python: Ein Schritt-für-Schritt-Tutorial

In diesem Abschnitt erfahren Sie, wie Sie Scrapy Splash verwenden können, um Daten von einer Website abzurufen. Die Zielseite ist eine spezielle JavaScript-gerenderte Version der beliebten “Quotes to Scrape“-Seite:

Dies ist genau wie das übliche “Quotes to Scrape”, aber es verwendet unendliches Scrollen, um Daten dynamisch über AJAX-Anfragen zu laden, die durch JavaScript ausgelöst werden.

Anforderungen

Um dieses Tutorial mit Scrapy Splash in Python zu wiederholen, muss Ihr System die folgenden Voraussetzungen erfüllen:

Python 3.10.1 oder höher.
Docker 27.5.1 oder höher.

Wenn Sie diese beiden Tools nicht auf Ihrem Rechner installiert haben, folgen Sie den oben genannten Links.

Voraussetzungen, Abhängigkeiten und Splash-Integration

Angenommen, Sie nennen den Hauptordner Ihres Projekts scrapy_splash/. Am Ende dieses Schritts wird der Ordner die folgende Struktur haben:

scrapy_splash/
    └── venv/

Das Verzeichnis venv/ enthält die virtuelle Umgebung. Sie können das Verzeichnis venv/ der virtuellen Umgebung wie folgt erstellen:

python -m venv venv

Um es zu aktivieren, führen Sie unter Windows aus:

venv\Scripts\activate

Unter macOS und Linux führen Sie die gleiche Funktion aus:

source venv/bin/activate

In der aktivierten virtuellen Umgebung installieren Sie die Abhängigkeiten mit:

pip install scrapy scrapy-splash

Als letzte Voraussetzung müssen Sie das Splash-Image über Docker ziehen:

docker pull scrapinghub/splash

Dann starten Sie den Container:

docker run -it -p 8050:8050 --rm scrapinghub/splash

Weitere Informationen finden Sie in den Anweisungen zur OS-basierten Docker-Integration.

Warten Sie nach dem Start des Docker-Containers, bis der Splash-Dienst die folgende Meldung protokolliert:

Server listening on http://0.0.0.0:8050

Die Meldung besagt, dass Splash jetzt unter http://0.0.0.0:8050 verfügbar ist . Rufen Sie diese URL in Ihrem Browser auf, und Sie sollten nun die folgende Seite sehen:

Je nach Ihrer Konfiguration funktioniert der Splash-Dienst möglicherweise nicht, wenn Sie die URL http://0.0.0.0:8050 aufrufen. Versuchen Sie in diesem Fall stattdessen, eine der folgenden Adressen zu verwenden:

http://localhost:8050
http://127.0.0.1:8050

Hinweis: Denken Sie daran, dass die Verbindung zum Splash-Server während der Verwendung von Scrapy-Splash geöffnet bleiben muss. Mit anderen Worten: Wenn Sie das CLI zum Ausführen des Docker-Containers verwendet haben, lassen Sie dieses Terminal geöffnet und verwenden Sie ein separates Terminal für die nächsten Schritte in diesem Verfahren.

Wunderbar! Jetzt haben Sie alles, was Sie brauchen, um Webseiten mit Scrapy Splash zu scrapen.

Schritt #1: Starten Sie ein neues Scrapy-Projekt

Geben Sie innerhalb des Hauptordners scrapy_splash/ den folgenden Befehl ein, um ein neues Scrapy-Projekt zu starten:

scrapy startproject quotes

Mit diesem Befehl erstellt Scrapy einen Ordner "quotes/ “. Innerhalb dieses Ordners werden automatisch alle benötigten Dateien erstellt. Dies ist die resultierende Ordnerstruktur:

scrapy_splash/
   ├──  quotes/ 
   │       ├── quotes/
   │       │      ├── spiders/ 
   │       │      ├── __init__.py  
   │       │      ├── items.py  
   │       │      ├── middlewares.py 
   │       │      ├── pipelines.py  
   │       │      └── settings.py  
   │       │     
   │       └── scrapy.cfg  
   └── venv/

Perfekt! Sie haben ein neues Scrapy-Projekt gestartet.

Schritt #2: Erzeugen Sie die Spinne

Um einen neuen Spider für das Crawlen der Ziel-Website zu erstellen, navigieren Sie zum Ordner quotes/:

cd quotes

Erzeugen Sie dann eine neue Spinne mit:

scrapy genspider words https://quotes.toscrape.com/scroll

Sie erhalten das folgende Ergebnis:

Created spider 'words' using template 'basic' in module:
  quotes.spiders.words

Wie Sie sehen können, hat Scrapy automatisch eine words.py-Datei im Ordner spiders/ erstellt. Die Datei words.py enthält den folgenden Code:

import scrapy

class WordsSpider(scrapy.Spider):
    name = "words"
    allowed_domains = ["quotes.toscrape.com"]
    start_urls = ["https://quotes.toscrape.com/scroll"]
    def parse(self, response):
        pass

Diese wird in Kürze die erforderliche Scraping-Logik der dynamischen Zielseite enthalten.

Hurra! Sie haben den Spider dazu gebracht, die Ziel-Website zu scrapen.

Schritt #3: Scrapy für die Verwendung von Splash konfigurieren

Nun müssen Sie Scrapy so konfigurieren, dass es den Splash-Dienst nutzen kann. Fügen Sie dazu die folgenden Konfigurationen in die Datei settings.py ein:

# Set the Splash local server endpoint
SPLASH_URL = "http://localhost:8050"
# Enable the Splash downloader middleware
DOWNLOADER_MIDDLEWARES = {
    "scrapy_splash.SplashCookiesMiddleware": 723,
    "scrapy_splash.SplashMiddleware": 725,
    "scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware": 810,
}
# Enable the Splash deduplication argument filter
SPIDER_MIDDLEWARES = {
    "scrapy_splash.SplashDeduplicateArgsMiddleware": 100,
}

In den oben genannten Konfigurationen:

SPLASH_URL legt den Endpunkt für den lokalen Splash-Server fest. Dorthin sendet Scrapy die Anfragen für das JavaScript-Rendering.
DOWNLOADER_MIDDLEWARES ermöglicht bestimmten Middlewares, mit Splash zu interagieren. Insbesondere
```
:Polylang-Platzhalter nicht ändern
```
SPIDER_MIDDLEWARES garantiert, dass Anfragen mit denselben Splash-Argumenten nicht doppelt gestellt werden, was zur Verringerung unnötiger Last und zur Verbesserung der Effizienz nützlich ist.

Ausführlichere Informationen zu diesen Konfigurationen finden Sie in der offiziellen Dokumentation zu Scrapy-Splash.

Sehr gut! Jetzt kann sich Scrapy mit Splash verbinden und es programmatisch für das JavaScript-Rendering verwenden.

Schritt 4: Definieren Sie das Lua-Skript für das JavaScript-Rendering

Scrapy kann jetzt mit Splash integriert werden, um Webseiten zu rendern, die auf JavaScript basieren, wie die Zielseite dieser Anleitung. Um eigene Rendering- und Interaktionslogik zu definieren, müssen Sie Lua-Skripte verwenden. Das liegt daran, dass Splash auf Lua-Skripte angewiesen ist, um mit Webseiten über JavaScript zu interagieren und das Verhalten des Browsers programmatisch zu steuern.

Fügen Sie insbesondere das folgende Lua-Skript zu words.py hinzu:

script = """
function main(splash, args)  
      splash:go(args.url)

      -- custom rendering script logic...

      return splash:html()
    end
"""

Im obigen Ausschnitt enthält die Skriptvariable die Lua-Logik, die Splash auf dem Server ausführen wird. Insbesondere weist dieses Skript Splash an,:

Navigieren Sie mit der Methode splash:go() zu der angegebenen URL.
Geben Sie den gerenderten HTML-Inhalt mit der Methode splash:html() zurück.

Verwenden Sie das obige Lua-Skript in einer start_requests() -Funktion innerhalb der WordsSpider-Klasse:

def start_requests(self):
    for url in self.start_urls:
        yield SplashRequest(
            url,
            self.parse,
            endpoint="execute",
            args={"lua_source": script}
        )

Die obige start_requests() -Methode setzt die Standardmethode start_requests() von Scrapy außer Kraft. Auf diese Weise kann Scrapy Splash das Lua-Skript ausführen, um das mit JavaScript gerenderte HTML der Seite abzurufen. Die Ausführung des Lua-Skripts erfolgt über das "lua_source": Skript-Argument in der SplashRequest() -Methode. Beachten Sie auch die Verwendung des Splash-Endpunkts "execute" (den Sie in Kürze näher kennenlernen werden).

Vergessen Sie nicht, SplashRequest aus Scrapy Splash zu importieren:

from scrapy_splash import SplashRequest

Ihre words.py-Datei ist nun mit dem richtigen Lua-Skript ausgestattet, um auf den mit JavaScript gerenderten Inhalt der Seite zuzugreifen!

Schritt Nr. 5: Definieren Sie die Logik der Datenanalyse

Bevor Sie beginnen, sollten Sie sich ein HTML-Element “quote” auf der Zielseite ansehen, um zu verstehen, wie es zu analysieren ist:

Dort können Sie sehen, dass die Zitatelemente mit .quote ausgewählt werden können. Bei einem Zitat können Sie dann erhalten:

Der Zitattext aus .text.
Der Autor des Zitats von .author.
Die Zitat-Tags von .tags.

Die Scraping-Logik zum Abrufen aller Zitate von der Zielseite kann durch die folgende parse() -Methode definiert werden:

def parse(self, response):
    # Retrieve CSS selectors
    quotes = response.css(".quote")
    for quote in quotes:
        yield {
            "text": quote.css(".text::text").get(),
            "author": quote.css(".author::text").get(),
            "tags": quote.css(".tags a.tag::text").getall()
        }

parse() verarbeitet die von Splash zurückgegebene Antwort. Im Einzelnen bedeutet dies:

Extrahiert alle div-Elemente mit der Klasse quote unter Verwendung des CSS-Selektors ".quote".
Iteriert über jedes Zitatelement, um den Namen, den Autor und den Tag für jedes Zitat zu extrahieren.

Sehr gut! Die Scrapy-Splash-Schrott-Logik ist vollständig.

Schritt Nr. 6: Alles zusammenstellen und das Skript ausführen

So sollte Ihre endgültige words.py-Datei aussehen:

import scrapy
from scrapy_splash import SplashRequest

# Lua script for JavaScript rendering
script = """
function main(splash, args)  
      splash:go(args.url)

      return splash:html()
    end
"""

class WordsSpider(scrapy.Spider):
    name = "words"
    start_urls = ["https://quotes.toscrape.com/scroll"]
    def start_requests(self):
        for url in self.start_urls:
            yield SplashRequest(
                url,
                self.parse,
                endpoint="execute",
                args={"lua_source": script}
            )
    def parse(self, response):
        quotes = response.css(".quote")
        for quote in quotes:
            yield {
                "text": quote.css(".text::text").get(),
                "author": quote.css(".author::text").get(),
                "tags": quote.css(".tags a.tag::text").getall()
            }

Führen Sie das Skript mit diesem Befehl aus:

scrapy crawl words

Dies ist das erwartete Ergebnis:

Alle mit Scrapy Splash gesammelten Zitate

Das angestrebte Ergebnis lässt sich wie folgt veranschaulichen:

2025-03-18 12:21:55 [scrapy.core.scraper] DEBUG: Scraped from <200 https://quotes.toscrape.com/scroll>
{'text': '“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”', 'author': 'Albert Einstein', 'tags': ['change', 'deep-thoughts', 'thinking', 'world']}

2025-03-18 12:21:55 [scrapy.core.scraper] DEBUG: Scraped from <200 https://quotes.toscrape.com/scroll>
{'text': '“It is our choices, Harry, that show what we truly are, far more than our abilities.”', 'author': 'J.K. Rowling', 'tags': ['abilities', 'choices']}

# omitted for brevity...

2025-03-18 12:21:55 [scrapy.core.engine] INFO: Closing spider (finished)

Beachten Sie, dass die Ausgabe die Daten von Interesse enthält.

Beachten Sie, dass Scrapy keine Daten zurückgibt, wenn Sie die Methode start_requests() aus der Klasse Words``Spider entfernen. Das liegt daran, dass es ohne Splash keine Seiten rendern kann, die JavaScript erfordern.

Sehr gut! Sie haben Ihr erstes Scrapy Splash-Projekt abgeschlossen.

Eine Anmerkung zu Splash

Splash ist ein Server, der über HTTP kommuniziert. Dadurch können Sie mit Splash Webseiten mit jedem HTTP-Client scrapen, indem Sie seine Endpunkte aufrufen. Die Endpunkte, die es bietet, sind:

ausführen: Führt ein benutzerdefiniertes Lua-Rendering-Skript aus und gibt dessen Ergebnis zurück.
render.html: Gibt den HTML-Code der mit Javascript gerenderten Seite zurück.
render.png: Gibt ein Bild (im PNG-Format) der mit Javascript gerenderten Seite zurück.
render.jpeg: Gibt ein Bild (im JPEG-Format) der mit Javascript gerenderten Seite zurück.
render.har: Gibt Informationen über die Splash-Interaktion mit einer Website im HAR-Format zurück.
render.json: Gibt ein JSON-kodiertes Wörterbuch mit Informationen über die mit Javascript gerenderte Webseite zurück. Es kann HTML-, PNG- und andere Informationen enthalten, die auf den übergebenen Argumenten basieren.

Um mehr über die Funktionsweise dieser Endpunkte zu erfahren, betrachten Sie den Endpunkt render.html. Stellen Sie mit diesem Python-Code eine Verbindung zu diesem Endpunkt her:

# pip install requests
import requests
import json

# URL of the Splash endpoint
url = "http://localhost:8050/render.html"

# Sending a POST request to the Splash endpoint
payload = json.dumps({
  "url": "https://quotes.toscrape.com/scroll" # URL of the page to render
})
headers = {
  "content-type": "application/json"
}
response = requests.request("POST", url, headers=headers, data=payload)
print(response.text)

Dieses Snippet definiert:

Die Splash-Instanz auf localhost als URL, die einen Aufruf an den Endpunkt render.html macht.
Die Zielseite, die innerhalb der Nutzlast abgerufen werden soll.

Führen Sie den obigen Code aus und Sie erhalten das gerenderte HTML der gesamten Seite:

<!DOCTYPE html>
<html lang="en">
  <head>
      <meta charset="UTF-8">
      <title>Quotes to Scrape</title>
      <link rel="stylesheet" href="/static/bootstrap.min.css">
      <link rel="stylesheet" href="/static/main.css">
  </head>
  <body>
      <!-- omitted for brevity... -->
  </body>
</html>

Während Splash JavaScript-gerendertes HTML unabhängig verarbeiten kann, macht die Verwendung von Scrapy Splash mit SplashRequest Web Scraping viel einfacher.

Scrapy Splash: Fortgeschrittene Scraping-Techniken

Im vorherigen Abschnitt haben Sie ein grundlegendes Scrapy-Tutorial mit Splash-Integration abgeschlossen. Zeit, einige fortgeschrittene Scraping-Techniken mit Scrapy Splash auszuprobieren!

Verwalten des erweiterten Bildlaufs

Die Zielseite enthält Zitate, die dank eines unendlichen Bildlaufs dynamisch über AJAX geladen werden:

Um die Interaktion mit dem unendlichen Scrollen zu steuern, müssen Sie das Lua-Skript wie folgt ändern:

script = """
function main(splash, args)
    local scroll_delay = 1.0  -- Time to wait between scrolls
    local max_scrolls = 10    -- Maximum number of scrolls to perform
    local scroll_to = 1000    -- Pixels to scroll down each time

    splash:go(args.url)
    splash:wait(scroll_delay)

    local scroll_count = 0
    while scroll_count < max_scrolls do
        scroll_count = scroll_count + 1
        splash:runjs("window.scrollBy(0, " .. scroll_to .. ");")
        splash:wait(scroll_delay)
    end

    return splash:html()
end
"""

Das geänderte Skript stützt sich auf diese Variablen:

max_scrolls definiert die maximale Anzahl der durchzuführenden Bildläufe. Dieser Wert muss möglicherweise geändert werden, je nachdem, wie viele Inhalte Sie von der Seite scrapen möchten.
scroll_to gibt die Anzahl der Pixel an, um die jedes Mal nach unten geblättert wird. Der Wert muss möglicherweise je nach Verhalten der Seite angepasst werden.
splash:runjs() führt die JavaScript-Funktion window.scrollBy() aus, um die Seite um die angegebene Anzahl von Pixeln nach unten zu scrollen.
splash:wait() sorgt dafür, dass das Skript wartet, bevor es neue Inhalte lädt. Die Dauer der Wartezeit (in Sekunden) wird durch die Variable scroll_delay bestimmt.

Vereinfacht ausgedrückt, simuliert das obige Lua-Skript eine bestimmte Anzahl von Bildläufen in einem Szenario mit unendlich vielen Bildläufen auf einer Webseite.

Der Code in der Datei words.py wird wie folgt aussehen:

import scrapy
from scrapy_splash import SplashRequest

# Lua script for infinite scrolling
script = """
function main(splash, args)
    local scroll_delay = 1.0  -- Time to wait between scrolls
    local max_scrolls = 10    -- Maximum number of scrolls to perform
    local scroll_to = 1000    -- Pixels to scroll down each time

    splash:go(args.url)
    splash:wait(scroll_delay)

    local scroll_count = 0
    while scroll_count < max_scrolls do
        scroll_count = scroll_count + 1
        splash:runjs("window.scrollBy(0, " .. scroll_to .. ");")
        splash:wait(scroll_delay)
    end

    return splash:html()
end
"""

class WordsSpider(scrapy.Spider):
    name = "words"
    start_urls = ["https://quotes.toscrape.com/scroll"]
    def start_requests(self):
        for url in self.start_urls:
            yield SplashRequest(
                url,
                self.parse,
                endpoint="execute",
                args={"lua_source": script}
            )
    def parse(self, response):
        # Retrieve CSS selectors
        quotes = response.css("div.quote")
        for quote in quotes:
            yield {
                "text": quote.css("span.text::text").get(),
                "author": quote.css("span small.author::text").get(),
                "tags": quote.css("div.tags a.tag::text").getall()
            }

Führen Sie das Skript mit dem unten stehenden Befehl aus:

scrapy crawl words

Der Crawler wird alle gescrapten Zitate in Übereinstimmung mit der max_scrolls-Variable ausgeben. Dies ist das erwartete Ergebnis:

Beachten Sie, dass die Ausgabe nun deutlich mehr Zitate enthält als zuvor. Dies bestätigt, dass die Seiten erfolgreich nach unten gescrollt wurden und neue Daten geladen und ausgelesen wurden.

Perfekt! Sie haben nun gelernt, wie Sie mit Scrapy Splash unendliches Scrollen steuern können.

Warten auf Element

Web-Seiten können Daten dynamisch abrufen oder Knoten im Browser rendern. Das bedeutet, dass das Rendern des endgültigen DOM einige Zeit in Anspruch nehmen kann. Um Fehler beim Abrufen von Daten von einer Website zu vermeiden, sollten Sie immer warten, bis ein Element auf der Seite geladen ist, bevor Sie mit ihm interagieren.

In diesem Beispiel ist das zu wartende Element der Text aus dem ersten Zitat:

Wie man den Text der Zitate auf der Zielseite abruft

Um die Wartelogik zu implementieren, schreiben Sie ein Lua-Skript wie folgt:

script = """
function main(splash, args)
       splash:go(args.url)

       while not splash:select(".text") do
         splash:wait(0.2)
         print("waiting...")
       end

       return { html=splash:html() }
    end
"""

Dieses Skript erstellt eine while-Schleife, die 0,2 Sekunden lang wartet, ob sich das Textelement auf der Seite befindet. Um zu überprüfen, ob sich das Textelement auf der Seite befindet, können Sie die Methode splash:select() verwenden.

Warten auf Zeit

Da das Laden und Rendern von Webseiten mit dynamischem Inhalt einige Zeit in Anspruch nimmt, können Sie einige Sekunden warten, bevor Sie auf den HTML-Inhalt zugreifen. Dies kann durch die Methode splash:wait() wie folgt erreicht werden:

script = """
function main(splash, args)
       splash:wait(args.wait)       
       splash:go(args.url)
       return { html=splash:html() }
    end
"""

In diesem Fall werden die Sekunden, die das Skript warten muss, in der Methode SplashRequest() mit einem Lua-Skript-Argument angegeben.

Setzen Sie zum Beispiel"wait" : 2.0, um dem Lua-Skript mitzuteilen, dass es 2 Sekunden warten soll:

import scrapy
from scrapy_splash import SplashRequest

script = """
function main(splash, args)
       splash:wait(args.wait)       
       splash:go(args.url)
       return { html=splash:html() }
    end
"""

class WordsSpider(scrapy.Spider):
    name = "words"
    start_urls = ["https://quotes.toscrape.com/scroll"]
    def start_requests(self):
        for url in self.start_urls:
            yield SplashRequest(
                url,
                self.parse,
                endpoint="execute",
                args={"lua_source": script, "wait": 2.0} # Waiting for 2 seconds
            )
# ...

Hinweis: Ein hartes Warten(splash:wait()) ist für lokale Tests nützlich, da es sicherstellt, dass die Seite geladen wird, bevor man fortfährt. Für die Produktion ist dieser Ansatz nicht ideal, da er zu unnötigen Verzögerungen führt und die Leistung und Skalierbarkeit beeinträchtigt. Außerdem können Sie nicht im Voraus wissen, wie lange Sie warten müssen.

Gut gemacht! Du hast gelernt, wie man in Scrapy Splash eine bestimmte Zeit warten kann.

Beschränkungen bei der Verwendung von Scrapy Splash

In diesem Tutorial haben Sie gelernt, wie Sie mit Scrapy Splash Daten aus dem Web in verschiedenen Szenarien extrahieren können. Diese Integration ist zwar einfach, hat aber auch einige Nachteile.

Zum Beispiel erfordert die Einrichtung von Splash die Ausführung eines separaten Splash-Servers mit Docker, was die Komplexität Ihrer Scraping-Infrastruktur erhöht. Außerdem ist die Lua-Skript-API von Splash im Vergleich zu moderneren Tools wie Puppeteer und Playwright etwas eingeschränkt.

Wie bei allen Headless-Browsern geht die größte Einschränkung jedoch vom Browser selbst aus. Anti-Scraping-Technologien können erkennen, wenn ein Browser automatisiert und nicht normal verwendet wird, was zu Skriptblockaden führt.

Vergessen Sie diese Herausforderungen mit Scraping Browser – einemspeziellen Cloud-basierten Scraping-Browser, der für unbegrenzte Skalierbarkeit ausgelegt ist. Er bietet CAPTCHA-Auflösung, Browser-Fingerabdruck-Verwaltung und Anti-Bot-Bypassing, sodass Sie sich keine Sorgen machen müssen, blockiert zu werden.

Schlussfolgerung

In diesem Artikel haben Sie gelernt, was Scrapy Splash ist und wie es funktioniert. Sie haben mit den Grundlagen begonnen und dann komplexere Scraping-Szenarien erkundet.

Sie haben auch die Grenzen des Tools entdeckt, insbesondere seine Anfälligkeit für Anti-Bot- und Anti-Scraping-Systeme. Zur Bewältigung dieser Herausforderungen ist Scraping Browser eine hervorragende Lösung. Dies ist nur eine der vielen Bright Data Scraping-Lösungen, die Sie ausprobieren können:

Proxy-Dienste: Vier verschiedene Arten von Proxys zur Umgehung von Standortbeschränkungen, darunter mehr als 150 Millionen private IPs
Web Scraper APIs: Spezielle Endpunkte zum Extrahieren von frischen, strukturierten Webdaten aus über 100 beliebten Domains.
SERP-API: API zur Verwaltung aller laufenden Freischaltungen für SERP und Extraktion einer Seite

Melden Sie sich jetzt bei Bright Data an und starten Sie Ihre kostenlose Testversion, um unsere Scraping-Lösungen zu testen.

Gratis testen

Starte mit Google

Keine Kreditkarte erforderlich

Web Scraping mit Scrapy Splash: Schritt-für-Schritt-Anleitung