---
title: "Web Scraping mit Scrapy Splash: Schritt-für-Schritt-Anleitung"
slug: web-scraping-with-scrapy-splash
date: 2025-05-06T11:19:38+00:00
modified: 2026-06-30T14:54:33+00:00
permalink: https://brightdata.de/blog/web-data-de/web-scraping-with-scrapy-splash
type: blog
---
[ Blog ](https://brightdata.de/blog "Blog") / [Web Data](https://brightdata.de/blog/web-data-de)
[Web Data](https://brightdata.de/blog/web-data-de)
# Web Scraping mit Scrapy Splash: Schritt-für-Schritt-Anleitung
Beherrschen Sie Scrapy Splash für Web-Scraping in Python. Lernen Sie, JavaScript zu rendern, Daten zu extrahieren und dynamische Seiten effizient zu bearbeiten.
17 min lesen
[  ](https://brightdata.com/blog/authors/federico-trotta)
[Federico Trotta
Technical Writer
](https://brightdata.com/blog/authors/federico-trotta)
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](https://github.com/scrapy-plugins/scrapy-splash) bezieht sich auf die Integration zwischen diesen beiden Tools:
- [**Scrapy**](https://scrapy.org/): Eine Open-Source-Crawling-Framework-Bibliothek in Python zum Extrahieren der benötigten Daten aus Websites.
- [**Splash**](https://github.com/scrapinghub/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](/blog/web-data-de/web-scraping-with-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 - an`](https://github.com/scrapy-plugins/scrapy-splash#requests)einen 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](https://www.selenium.dev/) oder [Playwright](https://playwright.dev/).
- 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:
1. [**Selenium**](/blog/wie/using-selenium-for-web-scraping): Eine vollwertige Browser-Automatisierungsfunktion für das Scraping von JavaScript-lastigen Websites, die interessante Erweiterungen wie [Selenium Wire](/blog/web-data-de/web-scraping-with-selenium-wire) bietet.
2. [**Playwright**](/blog/wie/playwright-web-scraping): Ein Open-Source-Browser-Automatisierungstool, das eine konsistente, browserübergreifende Automatisierung und eine robuste API bietet, die mehrere Programmiersprachen unterstützt.
3. [**Puppeteer**](/blog/wie/web-scraping-puppeteer): Eine Open-Source-Node.js-Bibliothek, die eine High-Level-API für die Automatisierung und Steuerung von Chrome über das [DevTools-Protokoll](https://chromedevtools.github.io/devtools-protocol/) 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](https://quotes.toscrape.com/scroll)“-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](https://www.python.org/downloads/) oder höher.
- [Docker 27.5.1](https://www.docker.com/) 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:
```none
scrapy_splash/
└── venv/
```
Das Verzeichnis `venv/` enthält die virtuelle Umgebung. Sie können das Verzeichnis `venv/` der [virtuellen Umgebung](https://docs.python.org/3/library/venv.html) wie folgt erstellen:
```none
python -m venv venv
```
Um es zu aktivieren, führen Sie unter Windows aus:
```none
venvScriptsactivate
```
Unter macOS und Linux führen Sie die gleiche Funktion aus:
```none
source venv/bin/activate
```
In der aktivierten virtuellen Umgebung installieren Sie die Abhängigkeiten mit:
```none
pip install scrapy scrapy-splash
```
Als letzte Voraussetzung müssen Sie [das Splash-Image über Docker ziehen](https://hub.docker.com/r/scrapinghub/splash):
```none
docker pull scrapinghub/splash
```
Dann starten Sie den Container:
```none
docker run -it -p 8050:8050 --rm scrapinghub/splash
```
Weitere Informationen finden Sie in [den Anweisungen zur OS-basierten Docker-Integration](https://splash.readthedocs.io/en/latest/install.html).
Warten Sie nach dem Start des Docker-Containers, bis der Splash-Dienst die folgende Meldung protokolliert:
```none
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:
```none
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:
```none
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/`:
```none
cd quotes
```
Erzeugen Sie dann eine neue Spinne mit:
```none
scrapy genspider words https://quotes.toscrape.com/scroll
```
Sie erhalten das folgende Ergebnis:
```none
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:
```none
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:
```none
# 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](https://github.com/scrapy-plugins/scrapy-splash?tab=readme-ov-file#configuration).
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](https://www.lua.org/) verwenden. Das liegt daran, dass [Splash auf Lua-Skripte angewiesen ist](https://splash.readthedocs.io/en/stable/scripting-tutorial.html), 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:
```none
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,:
1. Navigieren Sie mit der Methode [`splash:go()`](https://splash.readthedocs.io/en/stable/scripting-ref.html#splash-go) zu der angegebenen URL.
2. Geben Sie den gerenderten HTML-Inhalt mit der Methode [`splash:html()`](https://splash.readthedocs.io/en/stable/scripting-ref.html#splash-html) zurück.
Verwenden Sie das obige Lua-Skript in einer `start_requests()` -Funktion innerhalb der `WordsSpider-Klasse`:
```none
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()`](https://docs.scrapy.org/en/latest/topics/spiders.html#scrapy.Spider.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:
```none
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:
1. Der Zitattext aus `.text`.
2. Der Autor des Zitats von `.author`.
3. Die Zitat-Tags von `.tags`.
Die Scraping-Logik zum Abrufen aller Zitate von der Zielseite kann durch die folgende `parse()` -Methode definiert werden:
```none
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:
1. Extrahiert alle `div-Elemente` mit der Klasse `quote` unter Verwendung des CSS-Selektors `".quote"`.
2. 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:
```none
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:
```none
scrapy crawl words
```
Dies ist das erwartete Ergebnis:
Das angestrebte Ergebnis lässt sich wie folgt veranschaulichen:
```none
2026-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']}
2026-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...
2026-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`](https://splash.readthedocs.io/en/stable/api.html#execute): Führt ein benutzerdefiniertes Lua-Rendering-Skript aus und gibt dessen Ergebnis zurück.
- [`render.html`](https://splash.readthedocs.io/en/stable/api.html): Gibt den HTML-Code der mit Javascript gerenderten Seite zurück.
- [`render.png`](https://splash.readthedocs.io/en/stable/api.html#render-png): Gibt ein Bild (im PNG-Format) der mit Javascript gerenderten Seite zurück.
- [`render.jpeg`](https://splash.readthedocs.io/en/stable/api.html#render-jpeg): Gibt ein Bild (im JPEG-Format) der mit Javascript gerenderten Seite zurück.
- [`render.har`](https://splash.readthedocs.io/en/stable/api.html#render-har): Gibt Informationen über die Splash-Interaktion mit einer Website im HAR-Format zurück.
- [`render.json`](https://splash.readthedocs.io/en/stable/api.html#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:
```none
# 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:
```none
Quotes to Scrape
```
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:
```none
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()`](https://splash.readthedocs.io/en/latest/scripting-ref.html#splash-runjs) führt die JavaScript-Funktion [`window.scrollBy()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/scrollBy) aus, um die Seite um die angegebene Anzahl von Pixeln nach unten zu scrollen.
- [`splash:wait()`](https://splash.readthedocs.io/en/latest/scripting-ref.html#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:
```none
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:
```none
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:
Um die Wartelogik zu implementieren, schreiben Sie ein Lua-Skript wie folgt:
```none
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()`](https://splash.readthedocs.io/en/stable/scripting-ref.html#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:
```none
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](https://splash.readthedocs.io/en/stable/scripting-ref.html#splash-args) angegeben.
Setzen Sie zum Beispiel`"wait" : 2.0`, um dem Lua-Skript mitzuteilen, dass es 2 Sekunden warten soll:
```none
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](/blog/web-data-de/best-headless-browsers) 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 – einem**](/products/scraping-browser)speziellen 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**](/proxy-types): Vier verschiedene Arten von Proxys zur Umgehung von Standortbeschränkungen, darunter [mehr als 150 Millionen private IPs](/proxy-types/residential-proxies)
- [**Web Scraper APIs**](/products/web-scraper): Spezielle Endpunkte zum Extrahieren von frischen, strukturierten Webdaten aus über 100 beliebten Domains.
- [**SERP-API**](/products/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.
Vertrieb kontaktierenGratis testen
Inhaltsverzeichnis
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=Web+Scraping+mit+Scrapy+Splash%3A+Schritt-f%C3%BCr-Schritt-Anleitung&u=https://brightdata.de/blog/web-data-de/web-scraping-with-scrapy-splash) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Web+Scraping+mit+Scrapy+Splash%3A+Schritt-f%C3%BCr-Schritt-Anleitung&url=https://brightdata.de/blog/web-data-de/web-scraping-with-scrapy-splash) [ ](http://www.reddit.com/submit?title=Web+Scraping+mit+Scrapy+Splash%3A+Schritt-f%C3%BCr-Schritt-Anleitung&url=https://brightdata.de/blog/web-data-de/web-scraping-with-scrapy-splash)
## Das könnte Sie auch interessieren
[  ](https://brightdata.de/blog/ai/openhuman-with-bright-data "Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI")
[AI
Antonello Zanini
Technical Writer
### Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI
Integrieren Sie die Bright Data CLI mit OpenHuman, um produktionsreifen Web-Zugriff und Datenerhebung für KI-Agenten zu ermöglichen.
09-Sep-2026
12 min lesen
](https://brightdata.de/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax "Multimodales Web-Scraping mit MiniMax")
[Web Data
Antonello Zanini
Technical Writer
### Multimodales Web-Scraping mit MiniMax
Kombinieren Sie Bright Data Web Unlocker mit MiniMax M3 Vision, um strukturierte Daten aus Bildern und Webseiten-Screenshots zu extrahieren.
09-Sep-2026
4 min lesen
](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.de/blog/ai/best-cli-tools-for-codex "Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet")
[AI
Daniel Shashko
Web Data & AI Expert
### Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet
Die 10 CLI-Tools, die Codex schneller und leistungsfähiger machen, beginnend mit dem Bright Data CLI für echten Web-Zugriff aus der Sandbox heraus.
06-Sep-2026
20 min lesen
](https://brightdata.de/blog/ai/best-cli-tools-for-codex)