Skip to content

🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev

docs: Add German docs for the website

Karim shoair03221a0f177c
diff --git a/docs/README_DE.md b/docs/README_DE.md
index 7b1aece..6bb82bb 100644
--- a/docs/README_DE.md
+++ b/docs/README_DE.md
@@ -1,68 +1,68 @@
<!-- mcp-name: io.github.D4Vinci/Scrapling -->
<h1 align="center">
- <a href="https://scrapling.readthedocs.io">
+ <a href="https://scrapling.readthedocs.io/en/latest/de/">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/cover_dark.svg?sanitize=true">
- <img alt="Scrapling Poster" src="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/cover_light.svg?sanitize=true">
+ <img alt="Scrapling-Titelbild" src="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/cover_light.svg?sanitize=true">
</picture>
</a>
<br>
- <small>Effortless Web Scraping for the Modern Web</small>
+ <small>Daten aus dem modernen Web einfach extrahieren</small>
</h1>
<p align="center">
<a href="https://github.com/D4Vinci/Scrapling/actions/workflows/tests.yml" alt="Tests">
<img alt="Tests" src="https://github.com/D4Vinci/Scrapling/actions/workflows/tests.yml/badge.svg"></a>
- <a href="https://badge.fury.io/py/Scrapling" alt="PyPI version">
- <img alt="PyPI version" src="https://badge.fury.io/py/Scrapling.svg"></a>
+ <a href="https://badge.fury.io/py/Scrapling" alt="Version auf PyPI">
+ <img alt="Version auf PyPI" src="https://badge.fury.io/py/Scrapling.svg"></a>
<a href="https://hub.docker.com/r/pyd4vinci/scrapling" target="_blank">
- <img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/pyd4vinci/scrapling?labelColor=%20%23FDB062&logo=Docker&labelColor=%20%23528bff"></a>
- <a href="https://clickpy.clickhouse.com/dashboard/scrapling" rel="nofollow"><img src="https://img.shields.io/pypi/dm/scrapling" alt="PyPI package downloads"></a>
- <a href="https://scrapling.readthedocs.io/en/latest/ai/agent-skill.html" alt="AI Agent Skill">
- <img alt="Static Badge" src="https://img.shields.io/badge/Skill-black?style=flat&label=Agent&link=https%3A%2F%2Fscrapling.readthedocs.io%2Fen%2Flatest%2Fai%2Fagent-skill.html"></a>
- <a href="https://clawhub.ai/D4Vinci/scrapling-official" alt="OpenClaw Skill">
- <img alt="OpenClaw Skill" src="https://img.shields.io/badge/Clawhub-darkred?style=flat&label=OpenClaw&link=https%3A%2F%2Fclawhub.ai%2FD4Vinci%2Fscrapling-official"></a>
+ <img alt="Docker-Downloads" src="https://img.shields.io/docker/pulls/pyd4vinci/scrapling?labelColor=%20%23FDB062&logo=Docker&labelColor=%20%23528bff"></a>
+ <a href="https://clickpy.clickhouse.com/dashboard/scrapling" rel="nofollow"><img src="https://img.shields.io/pypi/dm/scrapling" alt="Paket-Downloads auf PyPI"></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/de/ai/agent-skill.html" alt="Skill für KI-Agenten">
+ <img alt="Agent-Skill-Badge" src="https://img.shields.io/badge/Skill-black?style=flat&label=Agent&link=https%3A%2F%2Fscrapling.readthedocs.io%2Fen%2Flatest%2Fde%2Fai%2Fagent-skill.html"></a>
+ <a href="https://clawhub.ai/D4Vinci/scrapling-official" alt="Skill für OpenClaw">
+ <img alt="Skill für OpenClaw" src="https://img.shields.io/badge/Clawhub-darkred?style=flat&label=OpenClaw&link=https%3A%2F%2Fclawhub.ai%2FD4Vinci%2Fscrapling-official"></a>
<br/>
<a href="https://discord.gg/EMgGbDceNQ" alt="Discord" target="_blank">
<img alt="Discord" src="https://img.shields.io/discord/1360786381042880532?style=social&logo=discord&link=https%3A%2F%2Fdiscord.gg%2FEMgGbDceNQ">
</a>
- <a href="https://x.com/Scrapling_dev" alt="X (formerly Twitter)">
- <img alt="X (formerly Twitter) Follow" src="https://img.shields.io/twitter/follow/Scrapling_dev?style=social&logo=x&link=https%3A%2F%2Fx.com%2FScrapling_dev">
+ <a href="https://x.com/Scrapling_dev" alt="X (ehemals Twitter)">
+ <img alt="Auf X (ehemals Twitter) folgen" src="https://img.shields.io/twitter/follow/Scrapling_dev?style=social&logo=x&link=https%3A%2F%2Fx.com%2FScrapling_dev">
</a>
<br/>
- <a href="https://pypi.org/project/scrapling/" alt="Supported Python versions">
- <img alt="Supported Python versions" src="https://img.shields.io/pypi/pyversions/scrapling.svg"></a>
+ <a href="https://pypi.org/project/scrapling/" alt="Unterstützte Python-Versionen">
+ <img alt="Unterstützte Python-Versionen" src="https://img.shields.io/pypi/pyversions/scrapling.svg"></a>
</p>
<p align="center">
- <a href="https://scrapling.readthedocs.io/en/latest/parsing/selection.html"><strong>Auswahlmethoden</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/de/parsing/selection.html"><strong>Auswahlmethoden</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/fetching/choosing.html"><strong>Einen Fetcher wählen</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/de/fetching/choosing.html"><strong>Einen Fetcher wählen</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/spiders/architecture.html"><strong>Spiders</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/de/spiders/architecture.html"><strong>Spider</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/spiders/proxy-blocking.html"><strong>Proxy-Rotation</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/de/spiders/proxy-blocking.html"><strong>Proxy-Rotation</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/cli/overview.html"><strong>CLI</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/de/cli/overview.html"><strong>CLI</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/ai/mcp-server.html"><strong>MCP-Modus</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/de/ai/mcp-server.html"><strong>MCP-Modus</strong></a>
</p>
-Scrapling ist ein Web-Scraping-Framework für Python, das schnelle HTTP-Anfragen, Stealth-Browser, leistungsstarkes Parsing und paralleles Crawling in einer Bibliothek vereint.
+Scrapling ist ein Web-Scraping-Framework für Python. Es vereint schnelle HTTP-Anfragen, Stealth-Browser, die Auswertung von Seiten und paralleles Crawling in einer Bibliothek.
-Scrapen Sie statische Seiten, rendern Sie JavaScript, interagieren Sie mit Websites und extrahieren Sie Daten aus den API-Aufrufen dahinter. Bauen Sie Crawler mit wiederverwendbaren Sessions, Proxy-Rotation, automatischen Wiederholungsversuchen, Pause & Resume und integriertem Datenexport.
+Extrahieren Sie Daten aus statischen Seiten, führen Sie JavaScript aus, bedienen Sie Websites und greifen Sie auf deren APIs zu. Erstellen Sie Crawler mit wiederverwendbaren Sitzungen, Proxy-Rotation, automatischen Wiederholungsversuchen, Pause und Fortsetzung sowie integriertem Datenexport.
-Nutzen Sie Scrapling in Python, im Terminal oder mit Ihrem KI-Agenten über den MCP-Server und den Agent Skill. Ob Sie nur ein paar Felder extrahieren oder eine ganze Website als sauberes Markdown sammeln möchten, Scrapling deckt den gesamten Scraping-Workflow ab.
+Nutzen Sie Scrapling in Python, im Terminal oder mit Ihrem KI-Agenten über den MCP-Server und den Agent Skill. Es deckt den ganzen Ablauf ab: von wenigen Feldern bis zum Speichern einer ganzen Website als saubere Markdown-Dateien.
## Was Sie mit Scrapling machen können
-- **[Abrufen & interagieren](https://scrapling.readthedocs.io/en/latest/fetching/choosing.html)**: Schnelle HTTP-Anfragen, Stealth-Browser, JavaScript-Rendering, Umgang mit Cloudflare Turnstile/Interstitial, persistente Sessions und Aufzeichnung von API-Aufrufen im Hintergrund.
-- **[Parsen & extrahieren](https://scrapling.readthedocs.io/en/latest/parsing/selection.html)**: CSS, XPath, Text- und Regex-Suche, adaptives Element-Tracking, Suche nach ähnlichen Elementen und saubere Markdown-Ausgabe.
-- **[Crawlen & exportieren](https://scrapling.readthedocs.io/en/latest/spiders/getting-started.html)**: Parallele Spiders, Proxy-Rotation, Wiederholungsversuche, AutoThrottle, Pause & Resume, Streaming, fertige Vorlagen und JSON/JSONL/CSV/XML-Exporte.
-- **[Scrapen mit KI oder im Terminal](https://scrapling.readthedocs.io/en/latest/ai/mcp-server.html)**: Ein MCP-Server für KI-Agenten zum Browsen und Extrahieren von Daten, ein Agent Skill, CLI-Befehle und eine interaktive Shell.
+- **[Seiten abrufen und bedienen](https://scrapling.readthedocs.io/en/latest/de/fetching/choosing.html)**: Schnelle HTTP-Anfragen, Stealth-Browser, JavaScript-Ausführung, Umgang mit Cloudflare Turnstile und Interstitial, dauerhafte Sitzungen und Aufzeichnung von API-Antworten im Hintergrund.
+- **[Seiten auswerten und Daten extrahieren](https://scrapling.readthedocs.io/en/latest/de/parsing/selection.html)**: Suche mit CSS, XPath, Text und regulären Ausdrücken, Wiederfinden von Elementen nach Änderungen der Seite, Suche nach ähnlichen Elementen und saubere Markdown-Ausgabe.
+- **[Crawlen und exportieren](https://scrapling.readthedocs.io/en/latest/de/spiders/getting-started.html)**: Parallele Spider, Proxy-Rotation, Wiederholungsversuche, AutoThrottle, Pause und Fortsetzung, Streaming, fertige Vorlagen und Export nach JSON, JSONL, CSV und XML.
+- **[Daten mit KI oder im Terminal extrahieren](https://scrapling.readthedocs.io/en/latest/de/ai/mcp-server.html)**: Ein MCP-Server zum Browsen und Extrahieren von Daten mit KI-Agenten, ein Agent Skill, CLI-Befehle und eine interaktive Shell.
-Starten Sie mit einer einzelnen Seite:
+Beginnen Sie mit einer einzelnen Seite:
```python
from scrapling.fetchers import Fetcher
@@ -72,7 +72,7 @@ quotes = page.css('.quote .text::text').getall()
print(quotes)
```
-Oder skalieren Sie mit einem Spider:
+Oder extrahieren Sie mehr Daten mit einem Spider:
```python
from scrapling.spiders import Spider, Response
@@ -110,7 +110,7 @@ Das gibt `10` aus und speichert Zitate und Autoren in `quotes.json`.
</a>
</td>
<td>
- <a href="https://go.nodemaven.com/scraplingseptember" target="_blank">NodeMaven</a> - der effizienteste Proxy-Anbieter für Web Scraping und Automatisierung mit der höchsten IP-Qualität auf dem Markt. Nutze den Code SCRAPLING35 für 35% Rabatt.
+ <a href="https://go.nodemaven.com/scraplingseptember" target="_blank">NodeMaven</a> - der effizienteste Proxy-Anbieter für Web Scraping und Automatisierung mit der höchsten IP-Qualität auf dem Markt. Nutzen Sie den Code SCRAPLING35 für 35 % Rabatt.
</td>
</tr>
<tr>
@@ -132,7 +132,7 @@ Das gibt `10` aus und speichert Zitate und Autoren in `quotes.json`.
<td>
<a href="https://evomi.com?utm_source=github&utm_medium=banner&utm_campaign=d4vinci-scrapling">
<b>Evomi</b>
- </a>: Residential-Proxies ab 0,49 $/GB. Scraping-Browser mit vollständig gefälschtem Chromium, Residential-IPs, automatischer CAPTCHA-Lösung und Anti-Bot-Umgehung. </br>
+ </a>: Residential-Proxys ab 0,49 $/GB. Scraping-Browser auf Chromium-Basis mit vollständig veränderten Fingerprints, Residential-IPs, automatischer CAPTCHA-Lösung und Anti-Bot-Umgehung. </br>
<b>Scraper-API für problemlose Ergebnisse. MCP- und N8N-Integrationen verfügbar.</b>
</td>
</tr>
@@ -143,7 +143,7 @@ Das gibt `10` aus und speichert Zitate und Autoren in `quotes.json`.
</a>
</td>
<td>
- <a href="https://tikhub.io/?utm_source=github.com/D4Vinci/Scrapling&utm_medium=marketing_social&utm_campaign=retargeting&utm_content=carousel_ad" target="_blank">TikHub.io</a> bietet über 900 stabile APIs auf mehr als 16 Plattformen, darunter TikTok, X, YouTube und Instagram, mit über 40 Mio. Datensätzen. <br /> Bietet außerdem <a href="https://ai.tikhub.io/?ref=KarimShoair" target="_blank">vergünstigte KI-Modelle</a> - Claude, GPT, GEMINI und mehr mit bis zu 71% Rabatt.
+ <a href="https://tikhub.io/?utm_source=github.com/D4Vinci/Scrapling&utm_medium=marketing_social&utm_campaign=retargeting&utm_content=carousel_ad" target="_blank">TikHub.io</a> bietet über 900 stabile APIs auf mehr als 16 Plattformen, darunter TikTok, X, YouTube und Instagram, mit über 40 Mio. Datensätzen. <br /> Bietet außerdem <a href="https://ai.tikhub.io/?ref=KarimShoair" target="_blank">vergünstigte KI-Modelle</a> - Claude, GPT, GEMINI und mehr mit bis zu 71 % Rabatt.
</td>
</tr>
<tr>
@@ -163,7 +163,7 @@ Das gibt `10` aus und speichert Zitate und Autoren in `quotes.json`.
</a>
</td>
<td>
- <a href="https://www.swiftproxy.net/?ref=D4Vinci" target="_blank">Swiftproxy</a> bietet skalierbare Residential-Proxys mit über 80 Mio. IPs in mehr als 195 Ländern und liefert schnelle, zuverlässige Verbindungen, automatische Rotation und starke Anti-Block-Leistung. Kostenlose Testversion verfügbar.
+ <a href="https://www.swiftproxy.net/?ref=D4Vinci" target="_blank">Swiftproxy</a> bietet skalierbare Residential-Proxys mit über 80 Mio. IPs in mehr als 195 Ländern und liefert schnelle, zuverlässige Verbindungen, automatische Rotation und wirksamen Schutz vor Sperren. Kostenlose Testversion verfügbar.
</td>
</tr>
<tr>
@@ -173,7 +173,7 @@ Das gibt `10` aus und speichert Zitate und Autoren in `quotes.json`.
</a>
</td>
<td>
- <a href="https://byteful.com/?utm_source=github&utm_medium=github-sponsor&utm_campaign=scrapling_github_sponsor" target="_blank">Byteful</a> bietet ethisch beschaffte Residential-, Mobil-, ISP- und Datacenter-Proxys sowie Tools für Web Scraping und KI-Automatisierung. Mit dem Code SCRAPLING10 erhalten Sie 10% Rabatt auf Residential-Proxys.
+ <a href="https://byteful.com/?utm_source=github&utm_medium=github-sponsor&utm_campaign=scrapling_github_sponsor" target="_blank">Byteful</a> bietet ethisch beschaffte Residential-, Mobil-, ISP- und Datacenter-Proxys sowie Tools für Web Scraping und KI-Automatisierung. Mit dem Code SCRAPLING10 erhalten Sie 10 % Rabatt auf Residential-Proxys.
</td>
</tr>
<tr>
@@ -183,7 +183,7 @@ Das gibt `10` aus und speichert Zitate und Autoren in `quotes.json`.
</a>
</td>
<td>
- <a href="https://proxylane.dev/?utm_source=scrapling&utm_medium=partnership&utm_campaign=scrapling_platinum_202609&utm_content=github_readme" target="_blank">ProxyLane</a>: Reduzieren Sie Sperren und CAPTCHAs um 90%. 28 Mio. Premium-Residential-IPs für umfangreiches Web Scraping. 195 Länder. Gezielte Auswahl nach Stadt/ISP/Postleitzahl. Sitzungen mit fester oder rotierender IP. Datenvolumen ohne Ablaufdatum ab $2/GB. Code <strong>SCRAPEANDTAKE</strong>: <em>25% Rabatt</em>.
+ <a href="https://proxylane.dev/?utm_source=scrapling&utm_medium=partnership&utm_campaign=scrapling_platinum_202609&utm_content=github_readme" target="_blank">ProxyLane</a>: Reduzieren Sie Sperren und CAPTCHAs um 90 %. 28 Mio. Premium-Residential-IPs für umfangreiches Web Scraping. 195 Länder. Gezielte Auswahl nach Stadt/ISP/Postleitzahl. Sitzungen mit fester oder rotierender IP. Datenvolumen ohne Ablaufdatum ab $2/GB. Code <strong>SCRAPEANDTAKE</strong>: <em>25 % Rabatt</em>.
</td>
</tr>
<tr>
@@ -203,7 +203,7 @@ Das gibt `10` aus und speichert Zitate und Autoren in `quotes.json`.
</a>
</td>
<td>
- $1/GB bei <a href="https://dataimpulse.com/?utm_source=website&utm_medium=github_readme&utm_campaign=scrapling_platinum" target="_blank">DataImpulse</a>. Ethisch bezogene Proxys aus erster Hand. Über 90 Mio. IPs, mehr als 195 Länder. Residential-, Datacenter- und Mobilproxies. Nutzungsabhängige Zahlung = kein Abo. Datenvolumen verfällt nie.
+ $1/GB bei <a href="https://dataimpulse.com/?utm_source=website&utm_medium=github_readme&utm_campaign=scrapling_platinum" target="_blank">DataImpulse</a>. Ethisch bezogene Proxys aus erster Hand. Über 90 Mio. IPs, mehr als 195 Länder. Residential-, Datacenter- und Mobilproxys. Nutzungsabhängige Zahlung = kein Abo. Datenvolumen verfällt nie.
</td>
</tr>
</table>
@@ -230,67 +230,73 @@ Das gibt `10` aus und speichert Zitate und Autoren in `quotes.json`.
---
-## Hauptmerkmale
-
-### Spiders -- Ein vollständiges Crawling-Framework
-- 🕷️ **Scrapy-ähnliche Spider-API**: Definieren Sie Spiders mit `start_urls`, async `parse` Callbacks und `Request`/`Response`-Objekten.
-- ⚡ **Paralleles Crawling**: Konfigurierbare Parallelitätslimits, domainbezogenes Throttling und Download-Verzögerungen.
-- 🔄 **Multi-Session-Unterstützung**: Einheitliche Schnittstelle für HTTP-Anfragen und heimliche Headless-Browser in einem einzigen Spider -- leiten Sie Anfragen per ID an verschiedene Sessions weiter.
-- 💾 **Pause & Resume**: Ausstehende Anfragen und besuchte URLs mit `crawldir` speichern. Mit Strg+C kontrolliert stoppen und mit demselben Verzeichnis neu starten.
-- 📡 **Streaming-Modus**: Gescrapte Elemente in Echtzeit streamen über `async for item in spider.stream()` mit Echtzeit-Statistiken -- ideal für UI, Pipelines und lang laufende Crawls.
-- 🛡️ **Erkennung blockierter Anfragen**: Automatische Erkennung und Wiederholung blockierter Anfragen mit anpassbarer Logik.
-- 🚦 **AutoThrottle**: Schluss mit dem Raten von Verzögerungen. Der Spider stimmt die Verzögerung jeder Domain selbst darauf ab, wie schnell die Website antwortet, verdoppelt sie (oder wartet, was `Retry-After` verlangt), sobald die Website Sie blockiert oder ausbremst, und wird wieder schneller, sobald das aufhört.
-- 🤖 **robots.txt-Konformität**: Optionales `robots_txt_obey`-Flag, das `Disallow`-, `Crawl-delay`- und `Request-rate`-Direktiven mit domainbasiertem Caching respektiert.
-- 🧪 **Entwicklungsmodus**: Antworten beim ersten Lauf auf der Festplatte zwischenspeichern und bei weiteren Läufen erneut abspielen - iterieren Sie an Ihrer `parse()`-Logik, ohne die Zielserver erneut abzufragen.
-- 🧩 **Fertige Spider-Vorlagen**: Sparen Sie sich den Boilerplate-Code mit `CrawlSpider` für regelbasiertes Link-Following, `SitemapSpider` für Sitemap-/robots.txt-gesteuerte Crawls, `XMLFeedSpider`/`CSVFeedSpider` für XML/RSS- und CSV-Feeds und `ShopifySpider` zum Sammeln von Produkten aus öffentlichen Shopify-Shops, ein Item pro Variante.
-- 🔗 **Link-Extraktion**: Ein eigenständiges `LinkExtractor`-Primitiv mit Allow-/Deny-Mustern, Domain-Filtern, CSS-/XPath-Eingrenzung, Erweiterungsfilterung und Kanonisierung -- nutzbar innerhalb der Vorlagen oder für sich allein.
-- 📦 **Integrierter Export**: Ergebnisse über Hooks und Ihre eigene Pipeline oder die integrierten JSON/JSONL/CSV/XML-Exporte mit `result.items.to_json()`, `to_jsonl()`, `to_csv()` und `to_xml()` exportieren.
-
-### Erweitertes Website-Abrufen mit Session-Unterstützung
-- **HTTP-Anfragen**: Schnelle und heimliche HTTP-Anfragen mit der `Fetcher`-Klasse. Kann Browser-TLS-Fingerprints und Header imitieren und HTTP/3 verwenden.
-- **Dynamisches Laden**: Dynamische Websites mit vollständiger Browser-Automatisierung über die `StealthyFetcher`-Klasse abrufen, die Playwrights Chromium und Google Chrome unterstützt.
-- **Anti-Bot-Umgehung**: Fortschrittliche Stealth-Funktionen mit `StealthyFetcher` und Fingerprint-Spoofing. Umgeht mit Automatisierung mühelos alle Arten von Cloudflare-Turnstile-/Interstitial-Challenges.
-- **Session-Verwaltung**: Persistente Session-Unterstützung mit den Klassen `FetcherSession` und `StealthySession` für Cookie- und Zustandsverwaltung über Anfragen hinweg.
-- **Proxy-Rotation**: Integrierter `ProxyRotator` mit zyklischen oder benutzerdefinierten Rotationsstrategien über alle Session-Typen hinweg, plus Proxy-Überschreibungen pro Anfrage.
-- **Domain- & Werbeblockierung**: Anfragen an bestimmte Domains (und deren Subdomains) blockieren oder die integrierte Werbeblockierung (~3.500 bekannte Werbe-/Tracker-Domains) in browserbasierten Fetchern aktivieren.
-- **DNS-Leak-Prävention**: Optionale DNS-over-HTTPS-Unterstützung zur Weiterleitung von DNS-Anfragen über Cloudflares DoH, um DNS-Leaks bei der Verwendung von Proxys zu verhindern.
-- **Remote-Browser**: Statt lokal einen Browser zu starten, verbinden Sie sich per CDP mit `cdp_url` zu einem bereits laufenden Browser -- auf demselben Rechner, einem anderen Host oder bei einem Managed-Browser-Anbieter. Mit `executable_path` können Sie jeden Browser-Fetcher außerdem auf Ihren eigenen Chromium-Build verweisen.
-- **Hintergrund-API-Erfassung**: Aktivieren Sie `record_requests=True` in einer Browsersitzung und durchsuchen Sie die gespeicherten Antworten mit `session.network.search(limit=None)`. Lesen Sie API-Daten und HTTP-Fehler über mehrere Seitenaufrufe hinweg, ohne Anfragen erneut zu senden. Der Verlauf ist begrenzt und speichert Text-Antwortkörper.
-- **Async-Unterstützung**: Vollständige async-Unterstützung über alle Fetcher und dedizierte async Session-Klassen hinweg.
-
-### Parsing und Datenextraktion
-- 🔄 **Intelligente Element-Verfolgung**: Elemente nach Website-Änderungen mit intelligenten Ähnlichkeitsalgorithmen neu lokalisieren.
-- 🎯 **Intelligente flexible Auswahl**: CSS-Selektoren, XPath-Selektoren, filterbasierte Suche, Textsuche, Regex-Suche und mehr.
-- 🔍 **Ähnliche Elemente finden**: Elemente, die gefundenen Elementen ähnlich sind, automatisch lokalisieren.
+## Wichtige Funktionen
+
+### Spider: ein vollständiges Crawling-Framework
+
+- 🕷️ **Spider-API ähnlich wie Scrapy**: Definieren Sie Spider mit `start_urls`, asynchronen `parse`-Callbacks sowie `Request`- und `Response`-Objekten.
+- ⚡ **Paralleles Crawling**: Legen Sie die Anzahl gleichzeitiger Anfragen, die Grenzen pro Domain und die Wartezeit zwischen Downloads fest.
+- 🔄 **Mehrere Sitzungen**: Nutzen Sie HTTP-Anfragen und Stealth-Browser ohne grafische Oberfläche im selben Spider. Leiten Sie Anfragen über die ID an unterschiedliche Sitzungen weiter.
+- 💾 **Pause und Fortsetzung**: Speichern Sie ausstehende Anfragen und besuchte URLs mit `crawldir`. Drücken Sie Strg+C, um sicher anzuhalten, und starten Sie mit demselben Ordner erneut.
+- 📡 **Ergebnisse als Stream**: Empfangen Sie Elemente direkt nach dem Extrahieren mit `async for item in spider.stream()`, zusammen mit Statistiken in Echtzeit. Das eignet sich für Oberflächen, Datenverarbeitung und lange Crawls.
+- 🛡️ **Blockierte Anfragen erkennen**: Erkennen und wiederholen Sie blockierte Anfragen automatisch. Sie können das Verhalten anpassen.
+- 🚦 **AutoThrottle**: Der Spider passt die Wartezeit pro Domain an die Antwortgeschwindigkeit der Website an. Blockiert oder begrenzt die Website Anfragen, verdoppelt er die Wartezeit oder hält die von `Retry-After` angegebene Zeit ein. Danach beschleunigt er wieder.
+- 🤖 **robots.txt beachten**: Aktivieren Sie `robots_txt_obey`, um die Vorgaben `Disallow`, `Crawl-delay` und `Request-rate` zu beachten. Die Angaben werden pro Domain zwischengespeichert.
+- 🧪 **Entwicklungsmodus**: Speichern Sie Antworten beim ersten Lauf auf der Festplatte und nutzen Sie sie danach erneut. So können Sie `parse()` anpassen, ohne neue Anfragen an die Server zu senden.
+- 🧩 **Fertige Spider-Vorlagen**: Nutzen Sie `CrawlSpider`, um Links nach Regeln zu folgen, `SitemapSpider` für Crawls über Sitemaps oder robots.txt, `XMLFeedSpider` und `CSVFeedSpider` zum Lesen von XML-, RSS- und CSV-Feeds sowie `ShopifySpider` zum Sammeln von Produkten aus öffentlichen Shopify-Shops, mit einem Element pro Variante.
+- 🔗 **Links extrahieren**: `LinkExtractor` erlaubt oder verwirft Links anhand von Mustern, filtert Domains und Dateiendungen, begrenzt die Suche mit CSS oder XPath und vereinheitlicht URLs. Nutzen Sie ihn mit den Vorlagen oder einzeln.
+- 📦 **Integrierter Export**: Exportieren Sie Ergebnisse mit Hooks und Ihrer eigenen Datenverarbeitung oder mit den integrierten Formaten JSON, JSONL, CSV und XML: `result.items.to_json()`, `to_jsonl()`, `to_csv()` und `to_xml()`.
+
+### Seiten mit Sitzungen abrufen
+
+- **HTTP-Anfragen**: Senden Sie schnelle und unauffällige HTTP-Anfragen mit `Fetcher`. Sie können TLS-Fingerprints und Header eines Browsers nachbilden und HTTP/3 nutzen.
+- **Dynamisches Laden**: Rufen Sie dynamische Websites mit vollständiger Browserautomatisierung über `StealthyFetcher` ab. Er unterstützt das Chromium von Playwright und Google Chrome.
+- **Antibot-Systeme umgehen**: `StealthyFetcher` verbirgt die Automatisierung und bildet Browser-Fingerprints nach. Er kann verschiedene Arten von Cloudflare Turnstile und Interstitial automatisch lösen.
+- **Sitzungen verwalten**: `FetcherSession` und `StealthySession` behalten Cookies und den Zustand zwischen Anfragen bei.
+- **Proxy-Rotation**: `ProxyRotator` wechselt Proxys zyklisch oder nach eigenen Regeln in allen Sitzungstypen. Sie können auch einen Proxy für eine einzelne Anfrage wählen.
+- **Domains und Werbung blockieren**: Blockieren Sie Anfragen an bestimmte Domains und deren Subdomains, oder aktivieren Sie den Werbeblocker der Browser-Fetcher. Er umfasst etwa 3.500 bekannte Werbe- und Tracking-Domains.
+- **DNS-Lecks verhindern**: Aktivieren Sie DNS-over-HTTPS, um DNS-Anfragen über den DoH-Dienst von Cloudflare zu senden und Lecks bei der Nutzung von Proxys zu verhindern.
+- **Entfernte Browser**: Verbinden Sie sich über CDP und `cdp_url` mit einem laufenden Browser, auf Ihrem Computer, einem anderen Server oder bei einem Browserdienst. Mit `executable_path` können Sie auch Ihre eigene Chromium-Version für jeden Browser-Fetcher verwenden.
+- **API-Antworten im Hintergrund aufzeichnen**: Aktivieren Sie `record_requests=True` in einer Browsersitzung und suchen Sie gespeicherte Antworten mit `session.network.search(limit=None)`. Lesen Sie API-Daten und HTTP-Fehler aus mehreren Seitenaufrufen, ohne die Anfragen zu wiederholen. Der Verlauf ist in seiner Größe begrenzt und speichert den Inhalt von Textantworten.
+- **Asynchroner Betrieb**: Alle Fetcher lassen sich asynchron nutzen. Dafür gibt es eigene Sitzungsklassen.
+
+### Seiten auswerten und Daten extrahieren
+
+- 🔄 **Elemente wiederfinden**: Finden Sie Elemente nach Änderungen der Website mit Algorithmen zur Ähnlichkeitssuche wieder.
+- 🎯 **Flexible Auswahl**: Nutzen Sie CSS, XPath, Filter, Text, reguläre Ausdrücke und mehr.
+- 🔍 **Ähnliche Elemente**: Finden Sie automatisch Elemente, die den bereits gefundenen ähneln.
### KI-Funktionen
-- 🤖 **MCP-Server**: Lassen Sie KI-Chatbots und -Agenten (Claude/Cursor/usw.) über Scrapling scrapen, mit HTTP-Anfragen, Browser-Aktionen, Screenshots, gespeicherten Anmeldungen und API-Antworten im Hintergrund. Mit unserem Stealth-Browser und den passenden Tools können geeignete KI-Modelle jedes CAPTCHA umgehen, das ihnen bei der Arbeit begegnet (ganz zu schweigen von unserem Cloudflare-Löser). Verschiedene Methoden reduzieren den Inhalt für das Modell, blockieren Werbung und schützen es vor Prompt-Injection. Remote-Browser über CDP und HTTP-Transport mit Authentifizierungsoptionen sind enthalten. ([Demo-Video](https://www.youtube.com/watch?v=qyFk3ZNwOxE))
-- 🧠 **Agent Skill**: Ein installationsfertiger [Agent Skill](https://scrapling.readthedocs.io/en/latest/ai/agent-skill.html), der Coding-Agents die gesamte Bibliothek beibringt, damit der Code, den sie mit Scrapling schreiben, zur aktuellen API passt, statt geraten zu werden.
-- 📚 **RAG-fertiges Markdown**: Wandeln Sie jede Seite mit einer Zeile (`page.markdown()`) in sauberes, bereinigtes, LLM-fertiges Markdown um oder crawlen Sie eine ganze Website mit der Vorlage `ContentSpider` in einen Markdown-Korpus, ganz ohne LLM im Prozess. ([Dokumentation](https://scrapling.readthedocs.io/en/latest/ai/building-rag-systems.html))
-
-### Hochleistungs- und praxiserprobte Architektur
-- 🚀 **Blitzschnell**: Optimierte Leistung, die die meisten Python-Scraping-Bibliotheken übertrifft.
-- 🔋 **Speichereffizient**: Optimierte Datenstrukturen und Lazy Loading für einen minimalen Speicher-Footprint.
-- ⚡ **Schnelle JSON-Serialisierung**: 10x schneller als die Standardbibliothek.
-- 🏗️ **Praxiserprobt**: Scrapling hat nicht nur eine Testabdeckung von 92% und eine vollständige Type-Hints-Abdeckung, sondern wird seit dem letzten Jahr täglich von Hunderten von Web Scrapern verwendet.
-
-### Entwickler-/Web-Scraper-freundliche Erfahrung
-- 🎯 **Interaktive Web-Scraping-Shell**: Optionale integrierte IPython-Shell mit Scrapling-Integration, Shortcuts und neuen Tools zur Beschleunigung der Web-Scraping-Skriptentwicklung, wie das Konvertieren von Curl-Anfragen in Scrapling-Anfragen und das Anzeigen von Anfrageergebnissen in Ihrem Browser.
-- 🚀 **Direkt vom Terminal aus verwenden**: Optional können Sie Scrapling verwenden, um eine URL zu scrapen, ohne eine einzige Codezeile zu schreiben!
-- 🛠️ **Umfangreiche Navigations-API**: Erweiterte DOM-Traversierung mit Eltern-, Geschwister- und Kind-Navigationsmethoden.
-- 🧬 **Verbesserte Textverarbeitung**: Integrierte Regex, Bereinigungsmethoden und optimierte String-Operationen.
-- 📝 **Automatische Selektorgenerierung**: Robuste CSS/XPath-Selektoren für jedes Element generieren.
-- 🔌 **Vertraute API**: Ähnlich wie Scrapy/BeautifulSoup mit denselben Pseudo-Elementen, die in Scrapy/Parsel verwendet werden.
-- 🤝 **Nahtlose Scrapy-Integration**: Sie setzen bereits auf Scrapy? Versehen Sie einen beliebigen Callback mit `scrapling_response`, um die ohnehin abgerufenen Responses mit Scraplings Parser zu verarbeiten -- ganz ohne Umschreiben.
-- 📘 **Vollständige Typabdeckung**: Vollständige Type Hints für hervorragende IDE-Unterstützung und Code-Vervollständigung. Die gesamte Codebasis wird bei jeder Änderung automatisch mit **PyRight** und **MyPy** gescannt.
-- 🔋 **Fertiges Docker-Image**: Mit jeder Veröffentlichung wird automatisch ein Docker-Image erstellt und gepusht, das alle Browser enthält.
+
+- 🤖 **MCP-Server**: Ermöglicht Assistenten und KI-Agenten wie Claude und Cursor, Daten mit Scrapling zu extrahieren. Dazu dienen HTTP-Anfragen, Browseraktionen, Screenshots, ein gespeicherter Anmeldezustand und API-Antworten im Hintergrund. Er nutzt unseren Stealth-Browser und Werkzeuge, mit denen geeignete Modelle CAPTCHAs lösen können, zusätzlich zum Cloudflare-Löser. Er verringert den an das Modell gesendeten Inhalt, blockiert Werbung und schützt vor Prompt Injection. Entfernte Browser über CDP und HTTP-Verbindungen mit Authentifizierungsoptionen sind ebenfalls möglich. ([Demovideo](https://www.youtube.com/watch?v=qyFk3ZNwOxE))
+- 🧠 **Agent Skill**: Ein [Agent Skill](https://scrapling.readthedocs.io/en/latest/de/ai/agent-skill.html) zum Installieren, der Coding-Agenten die Bibliothek erklärt. So schreiben sie Code, der zur aktuellen API passt.
+- 📚 **Markdown für RAG**: Wandeln Sie eine Seite mit einer Zeile (`page.markdown()`) in sauberes Markdown für Sprachmodelle um, oder speichern Sie mit der Vorlage `ContentSpider` eine ganze Website als Markdown-Dateien. Dafür ist kein Sprachmodell nötig. ([Dokumentation](https://scrapling.readthedocs.io/en/latest/de/ai/building-rag-systems.html))
+
+### Schnell und im Alltag erprobt
+
+- 🚀 **Hohe Geschwindigkeit**: Optimierte Leistung, die die meisten Web-Scraping-Bibliotheken für Python übertrifft.
+- 🔋 **Geringer Speicherbedarf**: Optimierte Datenstrukturen und Laden bei Bedarf.
+- ⚡ **Schnelle JSON-Ausgabe**: 10-mal schneller als die Standardbibliothek.
+- 🏗️ **In der Praxis getestet**: Tests decken 92 % von Scrapling ab, und der gesamte Code hat Typannotationen. Hunderte Menschen haben es im letzten Jahr täglich zur Datenextraktion verwendet.
+
+### Werkzeuge für Entwicklung und Datenextraktion
+
+- 🎯 **Interaktive Shell**: Eine optionale IPython-Shell mit Scrapling, Kurzbefehlen und Werkzeugen für die schnelle Entwicklung von Skripten. Wandeln Sie curl-Anfragen in Scrapling-Anfragen um und zeigen Sie Ergebnisse im Browser an.
+- 🚀 **Nutzung im Terminal**: Extrahieren Sie die Daten einer URL, ohne Code zu schreiben.
+- 🛠️ **Navigation im DOM**: Greifen Sie auf Eltern-, Geschwister- und Kindelemente zu.
+- 🧬 **Textverarbeitung**: Reguläre Ausdrücke, Textbereinigung und optimierte Arbeit mit Zeichenketten.
+- 📝 **Selektoren erzeugen**: Erstellen Sie zuverlässige CSS- und XPath-Selektoren für jedes Element.
+- 🔌 **Vertraute API**: Ähnlich wie Scrapy und BeautifulSoup, mit denselben Pseudoelementen wie Scrapy und Parsel.
+- 🤝 **Direkte Integration mit Scrapy**: Ergänzen Sie einen Callback um den Dekorator `scrapling_response`, um die bereits abgerufenen Antworten mit dem Scrapling-Parser auszuwerten. Sie müssen Ihr Programm nicht neu schreiben.
+- 📘 **Vollständige Typannotationen**: Sie helfen dem Editor, Code zu prüfen und zu vervollständigen. Der gesamte Code wird bei jeder Änderung automatisch mit **PyRight** und **MyPy** geprüft.
+- 🔋 **Fertiges Docker-Image**: Bei jeder Version wird automatisch ein Docker-Image mit allen Browsern erstellt und veröffentlicht.
## Erste Schritte
-Hier ein kurzer Überblick über das, was Scrapling kann, ohne zu sehr ins Detail zu gehen.
+Hier sehen Sie einige Beispiele für Scrapling.
### Grundlegende Verwendung
-HTTP-Anfragen mit Session-Unterstützung
+HTTP-Anfragen mit Sitzungen
```python
from scrapling.fetchers import Fetcher, FetcherSession
@@ -327,8 +333,8 @@ page = StealthyFetcher.fetch('https://quotes.toscrape.com/')
data = page.css('.quote .text::text').getall()
```
-### Spiders
-Vollständige Crawler mit parallelen Anfragen, mehreren Session-Typen und Pause & Resume erstellen:
+### Spider
+Erstellen Sie vollständige Crawler mit parallelen Anfragen, mehreren Sitzungstypen, Pause und Fortsetzung:
```python
from scrapling.spiders import Spider, Response
@@ -352,7 +358,7 @@ result = QuotesSpider().start()
print(f"{len(result.items)} Zitate gescrapt")
result.items.to_json("quotes.json")
```
-Mehrere Session-Typen in einem einzigen Spider verwenden:
+Verwenden Sie mehrere Sitzungstypen im selben Spider:
```python
from scrapling.spiders import Spider, Request, Response
from scrapling.fetchers import FetcherSession, AsyncStealthySession
@@ -373,13 +379,13 @@ class MultiSessionSpider(Spider):
else:
yield Request(link, sid="fast", callback=self.parse) # Expliziter Callback
```
-Lange Crawls mit Checkpoints pausieren und fortsetzen, indem Sie den Spider so starten:
+Speichern Sie den Fortschritt, um lange Crawls zu pausieren und fortzusetzen. Starten Sie den Spider so:
```python
QuotesSpider(crawldir="./crawl_data").start()
```
Mit gesetztem `crawldir` speichert Strg+C ausstehende Anfragen und bereits besuchte URLs. Starten Sie mit demselben `crawldir` neu, um fortzufahren. Speichern Sie extrahierte Daten separat.
-Oder überspringen Sie das Schreiben der Crawling-Logik komplett mit den fertigen Vorlagen, etwa um den gesamten Katalog eines Shopify-Shops abzurufen:
+Sie können auch eine fertige Vorlage verwenden. Rufen Sie zum Beispiel den ganzen Katalog eines Shopify-Shops ab:
```python
from scrapling.spiders import ShopifySpider
@@ -388,9 +394,9 @@ class MyStore(ShopifySpider):
result = MyStore().start() # Alle Produkte im Shop, ein Item pro Variante
```
-Die Vorlage liest Produkte aus öffentlichen Collection-Endpunkten, ein Item pro Variante.
+Die Vorlage liest Produkte aus den öffentlichen Endpunkten der Kollektionen, mit einem Element pro Variante.
-### Erweitertes Parsing & Navigation
+### Erweiterte Auswertung und Navigation
```python
from scrapling.fetchers import Fetcher
@@ -420,15 +426,15 @@ parent_container = first_quote.parent
similar_elements = first_quote.find_similar()
below_elements = first_quote.below_elements
```
-Sie können den Parser direkt verwenden, wenn Sie keine Websites abrufen möchten, wie unten gezeigt:
+Sie können den Parser direkt verwenden, ohne eine Webseite abzurufen:
```python
from scrapling.parser import Selector
page = Selector("<html>...</html>")
```
-Und es funktioniert genau auf die gleiche Weise!
+Er funktioniert auf dieselbe Weise.
-### Beispiele für async Session-Verwaltung
+### Beispiele für asynchrone Sitzungen
```python
import asyncio
from scrapling.fetchers import FetcherSession, AsyncStealthySession
@@ -447,13 +453,13 @@ async def main():
asyncio.run(main())
```
-## CLI & Interaktive Shell
+## CLI und interaktive Shell
-Scrapling enthält eine leistungsstarke Befehlszeilenschnittstelle:
+Sie können Scrapling auch im Terminal verwenden:
[![asciicast](https://asciinema.org/a/736339.svg)](https://asciinema.org/a/736339)
-Interaktive Web-Scraping-Shell starten
+Starten Sie die interaktive Web-Scraping-Shell:
```bash
pip install "scrapling[shell]"
scrapling shell
@@ -467,52 +473,52 @@ scrapling extract fetch 'https://nopecha.com/demo/cloudflare' captchas.html --cs
```
> [!NOTE]
-> Es gibt viele zusätzliche Funktionen, aber wir möchten diese Seite prägnant halten, einschließlich des MCP-Servers und der interaktiven Web-Scraping-Shell. Schauen Sie sich die vollständige Dokumentation [hier](https://scrapling.readthedocs.io/en/latest/) an
+> Weitere Funktionen, darunter der MCP-Server und die interaktive Shell, stehen in der [vollständigen Dokumentation](https://scrapling.readthedocs.io/en/latest/de/).
-## Leistungsbenchmarks
+## Leistungstests
-Scrapling ist nicht nur leistungsstark -- es ist auch blitzschnell. Die folgenden Benchmarks vergleichen Scraplings Parser mit den neuesten Versionen anderer beliebter Bibliotheken.
+Scrapling zeichnet sich auch durch seine Geschwindigkeit aus. Diese Tests vergleichen seinen Parser mit den neuesten Versionen anderer bekannter Bibliotheken.
-### Textextraktions-Geschwindigkeitstest (5000 verschachtelte Elemente)
+### Geschwindigkeit der Textextraktion (5.000 verschachtelte Elemente)
-| # | Bibliothek | Zeit (ms) | vs Scrapling |
+| # | Bibliothek | Zeit (ms) | Im Vergleich zu Scrapling |
|---|:-----------------:|:---------:|:------------:|
-| 1 | Scrapling | 1.99 | 1.0x |
-| 2 | Parsel/Scrapy | 2.06 | 1.035 |
-| 3 | Raw Lxml | 2.56 | 1.286 |
-| 4 | PyQuery | 23.98 | ~12x |
-| 5 | Selectolax | 197.02 | ~99x |
-| 6 | MechanicalSoup | 1545.15 | ~776.5x |
-| 7 | BS4 with Lxml | 1562.1 | ~785.0x |
-| 8 | BS4 with html5lib | 3412.73 | ~1714.9x |
+| 1 | Scrapling | 1,99 | 1,0x |
+| 2 | Parsel/Scrapy | 2,06 | 1,035 |
+| 3 | Lxml allein | 2,56 | 1,286 |
+| 4 | PyQuery | 23,98 | ~12x |
+| 5 | Selectolax | 197,02 | ~99x |
+| 6 | MechanicalSoup | 1545,15 | ~776,5x |
+| 7 | BS4 mit Lxml | 1562,1 | ~785,0x |
+| 8 | BS4 mit html5lib | 3412,73 | ~1714,9x |
-### Element-Ähnlichkeit & Textsuche-Leistung
+### Suche nach ähnlichen Elementen und Text
-Scraplings adaptive Element-Finding-Fähigkeiten übertreffen Alternativen deutlich:
+Die adaptive Elementsuche von Scrapling ist schneller als die Alternativen:
-| Bibliothek | Zeit (ms) | vs Scrapling |
+| Bibliothek | Zeit (ms) | Im Vergleich zu Scrapling |
|-------------|:---------:|:------------:|
-| Scrapling | 2.3 | 1.0x |
-| AutoScraper | 12.58 | 5.47x |
+| Scrapling | 2,3 | 1,0x |
+| AutoScraper | 12,58 | 5,47x |
-> Alle Benchmarks stellen Durchschnittswerte von über 100 Durchläufen dar. Siehe [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py) für die Methodik.
+> Jedes Ergebnis ist der Durchschnitt aus mindestens 100 Durchläufen. Die Methode steht in [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py).
## Installation
-Scrapling erfordert Python 3.10 oder höher:
+Scrapling benötigt Python 3.10 oder neuer:
```bash
pip install scrapling
```
> [!IMPORTANT]
-> Diese Installation enthält nur die Parser-Engine und ihre Abhängigkeiten, ohne Fetcher oder Kommandozeilenabhängigkeiten. Daher führt der Import von allem aus `scrapling.fetchers` oder `scrapling.spiders`, wie in den Beispielen oben, mit dieser Installation allein zu einem `ModuleNotFoundError`. Wenn Sie einen der Fetcher oder Spider verwenden möchten, installieren Sie zuerst die Fetcher-Abhängigkeiten wie unten gezeigt.
+> Dieser Befehl installiert nur den Parser und seine Abhängigkeiten, ohne Fetcher oder Werkzeuge für die Kommandozeile. Wenn Sie nur das installieren, führt ein Import aus `scrapling.fetchers` oder `scrapling.spiders`, wie in den Beispielen oben, zu `ModuleNotFoundError`. Für Fetcher oder Spider müssen Sie zuerst die Fetcher-Abhängigkeiten wie unten gezeigt installieren.
### Optionale Abhängigkeiten
-1. Wenn Sie eine der folgenden zusätzlichen Funktionen, die Fetcher oder ihre Klassen verwenden möchten, müssen Sie die Abhängigkeiten der Fetcher und ihre Browser-Abhängigkeiten wie folgt installieren:
+1. Für Fetcher, deren Klassen oder die folgenden Zusatzfunktionen installieren Sie die Abhängigkeiten der Fetcher und Browser:
```bash
pip install "scrapling[fetchers]"
@@ -520,9 +526,9 @@ pip install scrapling
scrapling install --force # force reinstall
```
- Dies lädt alle Browser zusammen mit ihren Systemabhängigkeiten und Fingerprint-Manipulationsabhängigkeiten herunter.
+ Dadurch werden alle Browser, ihre Systemabhängigkeiten und die Werkzeuge zum Ändern der Browser-Fingerprints heruntergeladen.
- Oder Sie können sie aus dem Code heraus installieren, anstatt einen Befehl auszuführen:
+ Sie können sie auch aus Python installieren, statt einen Befehl auszuführen:
```python
from scrapling.cli import install
@@ -530,16 +536,16 @@ pip install scrapling
install(["--force"], standalone_mode=False) # force reinstall
```
-2. Zusätzliche Funktionen:
- - MCP-Server-Funktion installieren:
+2. Zusatzfunktionen:
+ - Den MCP-Server installieren:
```bash
pip install "scrapling[ai]"
```
- - Abhängigkeiten für ([RAG-Systeme erstellen](https://scrapling.readthedocs.io/en/latest/ai/building-rag-systems.html)) installieren:
+ - Die Abhängigkeiten zum [Aufbau von RAG-Systemen](https://scrapling.readthedocs.io/en/latest/de/ai/building-rag-systems.html) installieren:
```bash
pip install "scrapling[rag]"
```
- - Shell-Funktionen installieren (Web-Scraping-Shell und der `extract`-Befehl):
+ - Die interaktive Shell und den Befehl `extract` installieren:
```bash
pip install "scrapling[shell]"
```
@@ -547,30 +553,30 @@ pip install scrapling
```bash
pip install "scrapling[all]"
```
- Führen Sie `scrapling install` aus, wenn Sie Browser-Fetcher benötigen. HTTP-Anfragen brauchen keine Browser-Installation.
+ Führen Sie `scrapling install` aus, wenn Sie Browser-Fetcher nutzen möchten. HTTP-Anfragen benötigen keinen Browser.
### Docker
-Sie können auch ein Docker-Image mit allen Extras und Browsern mit dem folgenden Befehl von DockerHub installieren:
+Sie können auch ein Docker-Image mit allen Extras und Browsern von DockerHub herunterladen:
```bash
docker pull pyd4vinci/scrapling
```
-Oder laden Sie es aus der GitHub-Registry herunter:
+Oder aus der GitHub-Registry herunterladen:
```bash
docker pull ghcr.io/d4vinci/scrapling:latest
```
-Dieses Image wird automatisch mit GitHub Actions und dem Hauptzweig des Repositorys erstellt und gepusht.
+Das Image wird aus dem Hauptbranch des Repositorys erstellt und von GitHub Actions automatisch veröffentlicht.
-## Beitragen
+## Mitwirken
Wir freuen uns über Beiträge! Bitte lesen Sie unsere [Beitragsrichtlinien](https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md), bevor Sie beginnen.
## Haftungsausschluss
> [!CAUTION]
-> Diese Bibliothek wird nur zu Bildungs- und Forschungszwecken bereitgestellt. Durch die Nutzung dieser Bibliothek erklären Sie sich damit einverstanden, lokale und internationale Gesetze zum Daten-Scraping und Datenschutz einzuhalten. Die Autoren und Mitwirkenden sind nicht verantwortlich für Missbrauch dieser Software. Respektieren Sie immer die Nutzungsbedingungen von Websites und robots.txt-Dateien.
+> Diese Bibliothek dient nur der Bildung und Forschung. Mit ihrer Nutzung stimmen Sie zu, die lokalen und internationalen Gesetze zur Datenextraktion und zum Datenschutz einzuhalten. Die Autoren und Mitwirkenden sind nicht für den Missbrauch dieser Software verantwortlich. Beachten Sie die Nutzungsbedingungen der Websites und die robots.txt-Dateien.
-## 🎓 Zitierungen
-Wenn Sie unsere Bibliothek für Forschungszwecke verwendet haben, zitieren Sie uns bitte mit der folgenden Referenz:
+## 🎓 Zitieren
+Wenn Sie diese Bibliothek in Ihrer Forschung verwendet haben, zitieren Sie sie mit dieser Referenz:
```text
@misc{scrapling,
author = {Karim Shoair},
@@ -583,12 +589,12 @@ Wenn Sie unsere Bibliothek für Forschungszwecke verwendet haben, zitieren Sie u
## Lizenz
-Diese Arbeit ist unter der BSD-3-Clause-Lizenz lizenziert.
+Dieses Projekt nutzt die BSD-3-Clause-Lizenz.
## Danksagungen
Dieses Projekt enthält angepassten Code von:
-- Parsel (BSD-Lizenz) -- Verwendet für das [translator](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/translator.py)-Submodul
+- Parsel (BSD-Lizenz): verwendet für das Submodul [translator](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/translator.py)
---
<div align="center"><small>Entworfen und hergestellt mit ❤️ von Karim Shoair.</small></div><br>
diff --git a/docs/locales/de/ai/agent-skill.md b/docs/locales/de/ai/agent-skill.md
new file mode 100644
index 0000000..98f286a
--- /dev/null
+++ b/docs/locales/de/ai/agent-skill.md
@@ -0,0 +1,42 @@
+---
+title: "Scrapling Agent Skill: Installation und Nutzung"
+description: "Installieren Sie den Scrapling-Skill für Ihren Coding-Agenten. Geben Sie ihm aktuelle API-Beispiele und Referenzen zum Abrufen, Parsen und Crawlen von Seiten."
+---
+
+# Scrapling Agent Skill {#scrapling-agent-skill}
+
+Der [MCP-Server](mcp-server.md) gibt KI-Chatbots Werkzeuge, um Daten von Websites zu extrahieren. Der **Scrapling Agent Skill** bringt Coding-Agenten die Bibliothek selbst bei. So nutzt der Code, den sie mit Scrapling schreiben, die aktuelle API statt veralteter Informationen aus ihren Trainingsdaten.
+
+Der Skill folgt der [AgentSkills](https://agentskills.io/specification)-Spezifikation. Damit können ihn [Claude Code](https://claude.com/product/claude-code), [OpenClaw](https://github.com/openclaw/openclaw) und andere Agenten-Werkzeuge lesen. Er enthält Markdown-Anleitungen zum Abrufen, Parsen und Crawlen von Seiten sowie zu MCP und RAG. Der Agent lädt sie bei Bedarf. Dazu kommen sofort ausführbare Beispiele. So kann er die meisten Fragen zu Scrapling beantworten und passenden Scraping-Code schreiben, ohne Ihren Editor zu verlassen.
+
+Der Skill liegt im Ordner [agent-skill](https://github.com/D4Vinci/Scrapling/tree/main/agent-skill) des Repositorys unter dem Namen `scrapling-official`. Seine Version entspricht immer der Version der Bibliothek.
+
+## Installation {#installation}
+
+### Skills.sh {#skillssh}
+
+Installieren Sie den Skill aus dem Repository mit der CLI von [skills.sh](https://skills.sh):
+```bash
+npx skills add D4Vinci/Scrapling --skill scrapling-official
+```
+Die CLI erkennt Ihre installierten Agenten und fügt ihnen den Skill hinzu.
+
+### Clawhub {#clawhub}
+
+Wenn Sie OpenClaw nutzen, können Sie den Skill über [Clawhub](https://docs.openclaw.ai/tools/clawhub) installieren:
+```bash
+clawhub install scrapling-official
+```
+Oder installieren Sie ihn über seine [Clawhub-Seite](https://clawhub.ai/D4Vinci/scrapling-official).
+
+### Manueller Download {#manual-download}
+
+Laden Sie die ZIP-Datei des Skills [direkt aus dem Repository](https://github.com/D4Vinci/Scrapling/raw/refs/heads/main/agent-skill/Scrapling-Skill.zip) herunter. Entpacken Sie sie in den Skills-Ordner Ihres Agenten. Bei Claude Code ist das `~/.claude/skills/`.
+
+## Inhalt des Skills {#whats-inside}
+
+- **`SKILL.md`**: Die Datei, die der Agent zuerst liest. Sie erklärt die Einrichtung, die Auswahl des Fetchers und die Sicherheitsregeln. Zum Beispiel muss der Agent bei CLI-Befehlen immer `--ai-targeted` verwenden, um sich vor Prompt Injection zu schützen.
+- **`references/`**: Markdown-Kopien der Dokumentation zu Parsing, Fetchern, Spidern, dem MCP-Server und Integrationen. Sie werden erst bei Bedarf geladen und belegen vorher keinen Platz im Kontext des Agenten.
+- **`examples/`**: Sofort ausführbare Skripte, die der Agent als Vorlage verwenden kann.
+
+Wir haben den Skill mit OpenClaw und Claude Code getestet. Falls Sie Probleme haben, öffnen Sie ein [Ticket](https://github.com/D4Vinci/Scrapling/issues/new/choose) oder melden Sie sich auf unserem [Discord-Server](https://discord.gg/EMgGbDceNQ).
diff --git a/docs/locales/de/ai/building-rag-systems.md b/docs/locales/de/ai/building-rag-systems.md
new file mode 100644
index 0000000..8f0f0e3
--- /dev/null
+++ b/docs/locales/de/ai/building-rag-systems.md
@@ -0,0 +1,109 @@
+---
+title: "Websites mit Scrapling für RAG in Markdown umwandeln"
+description: "Wandeln Sie Seitenantworten in Markdown um oder sammeln Sie eine Website mit ContentSpider. Bereiten Sie Texte zum Aufteilen und Indexieren in einem RAG-System vor."
+---
+
+# RAG-Systeme mit Scrapling erstellen {#building-rag-systems-with-scrapling}
+
+RAG-Systeme sind nur so gut wie der Text, den sie erhalten. Rohes HTML verbraucht Tokens für Markup, Navigation, Skripte und Tracking-Inhalte. Es kann sogar versteckte Anweisungen für Prompt Injection an Ihr LLM weitergeben. Scrapling wandelt Seiten und ganze Websites in sauberes Markdown um und entfernt solche Inhalte. Dafür ist kein LLM nötig. So ist die Datenerfassung schnell und kostet nichts pro Seite.
+
+## Installation {#installation}
+
+```bash
+pip install "scrapling[rag]"
+
+scrapling install
+```
+
+Das Extra `rag` installiert die Fetcher mit Markdown-Unterstützung. Die Extras `ai`, `shell` und `all` enthalten sie ebenfalls. Der Befehl `scrapling install` lädt die Browser-Abhängigkeiten herunter. Diese brauchen Sie nur für Fetcher, die einen Browser verwenden.
+
+## Eine Seite in Markdown umwandeln {#one-page-to-markdown}
+
+Jedes [Response](../fetching/choosing.md#response-object)-Objekt hat eine Methode `markdown()`:
+
+```python
+from scrapling.fetchers import Fetcher
+
+markdown = Fetcher.get("https://example.com").markdown(main_content_only=True)
+```
+
+Sie funktioniert mit allen Fetchern. Damit können Sie auch Seiten hinter Cloudflare mit einer Zeile abrufen:
+
+```python
+from scrapling.fetchers import StealthyFetcher
+
+markdown = StealthyFetcher.fetch("https://protected.example.com", solve_cloudflare=True).markdown(main_content_only=True)
+```
+
+Zwei Argumente steuern die Ausgabe:
+
+- `main_content_only`: Wandelt nur den Inhalt innerhalb des `<body>`-Tags der Seite um.
+- `css_selector`: Wandelt nur die Elemente um, die zu einem CSS-Selektor passen, und verbindet alle Treffer. Nutzen Sie dies, um genau den benötigten Teil zu extrahieren und Tokens zu sparen:
+
+```python
+markdown = Fetcher.get("https://example.com/docs/page").markdown(css_selector="article")
+```
+
+Unabhängig von den Argumenten werden Skripte, Styles und versteckte Inhalte vor der Umwandlung immer entfernt. Dies ist dieselbe Bereinigung, mit der der [MCP-Server](mcp-server.md) KI-Agenten vor Prompt Injection schützt. Sie entfernt durch Inline-Styles versteckte Elemente, Elemente mit `aria-hidden="true"`, versteckte Slots, `<template>`-Tags, HTML-Kommentare und Zeichen mit der Breite null. Der MCP-Server nutzt diese Bereinigung mit `main_content_only=True`.
+
+## Eine ganze Website in Markdown-Dateien umwandeln {#a-whole-website-to-a-markdown-corpus}
+
+Die Vorlage `ContentSpider` crawlt eine Website und wandelt jede Seite um. Sie nutzt das [Spider-Framework](../spiders/architecture.md). Damit sind gleichzeitige Anfragen, AutoThrottle, die Beachtung von robots.txt sowie Pause und Fortsetzung bereits enthalten:
+
+```python
+from scrapling.spiders import ContentSpider
+
+class DocsSpider(ContentSpider):
+ name = "docs"
+ start_urls = ["https://example.com/docs/"]
+ allowed_domains = {"example.com"}
+ output_dir = "docs_markdown"
+ max_pages = 200
+
+result = DocsSpider().start()
+result.items.to_jsonl("docs.jsonl")
+```
+
+Jede besuchte Seite wird zu einem Datensatz mit den Schlüsseln `url`, `title` und `markdown`. Wenn Sie `output_dir` festlegen, wird jede Seite auch in eine Markdown-Datei geschrieben, deren Name auf ihrer URL beruht. Das Beispiel oben erzeugt also einen Ordner mit `.md`-Dateien und eine `docs.jsonl`, die Sie direkt weiterverarbeiten können.
+
+Die Vorlage erfordert `allowed_domains`, damit der Crawl auf die gewünschte Website beschränkt bleibt. Folgende Optionen sind verfügbar:
+
+- `css_selector` / `main_content_only`: Werden für jede Seite an `markdown()` übergeben. `main_content_only` ist standardmäßig aktiviert.
+- `output_dir`: Wenn gesetzt, wird pro Seite eine Markdown-Datei geschrieben.
+- `max_pages`: Maximale Anzahl der umzuwandelnden Seiten. Anfragen, die beim Erreichen der Grenze schon in der Warteschlange stehen, können noch abgerufen werden. Ihre Seiten werden aber nicht umgewandelt. Der Standardwert `0` schaltet die Grenze aus.
+
+Standardmäßig werden alle Seitenlinks innerhalb von `allowed_domains` verfolgt. Da die Vorlage auf [CrawlSpider](../spiders/generic-templates.md#crawlspider) aufbaut, können Sie `rules()` mit einem eigenen [LinkExtractor](../spiders/generic-templates.md#linkextractor-reference) überschreiben, um den Crawl zu steuern. `allow` beschränkt ihn auf gewünschte URL-Muster. `deny` schließt unerwünschte Muster aus, etwa die von Anmeldeseiten, Tag-Listen oder Druckansichten:
+
+```python
+from scrapling.spiders import CrawlRule, LinkExtractor, ContentSpider
+
+class DocsSpider(ContentSpider):
+ name = "docs"
+ start_urls = ["https://example.com/"]
+ allowed_domains = {"example.com"}
+
+ def rules(self):
+ return [CrawlRule(LinkExtractor(allow=r"/docs/", deny=[r"/docs/changelog/", r"\?print="]))]
+```
+
+`deny` hat Vorrang vor `allow`. Wie bei jedem **CrawlSpider** kann eine Regel eine `priority` oder einen Hook `process_request` enthalten.
+
+## Daten in einen Vektorspeicher laden {#feeding-a-vector-store}
+
+Die JSONL-Ausgabe lässt sich in jede Embedding-Pipeline einbinden. Ein einfaches Beispiel:
+
+```python
+import json
+
+with open("docs.jsonl", encoding="utf-8") as f:
+ for line in f:
+ page = json.loads(line)
+ for chunk in split_into_chunks(page["markdown"]):
+ vector_store.add(text=chunk, metadata={"url": page["url"], "title": page["title"]})
+```
+
+Entfernen Sie wiederkehrende Inhalte mit `css_selector` im Spider, bevor Sie den Text in Abschnitte aufteilen. So müssen Sie ihn später nicht mehr bereinigen. Je weniger unnötige Inhalte in den Embeddings stecken, desto besser werden die Suchergebnisse.
+
+## Interaktive Alternativen {#interactive-alternatives}
+
+Wenn Sie Daten lieber im Gespräch extrahieren, gibt der [MCP-Server](mcp-server.md) Ihrem KI-Chatbot Werkzeuge mit derselben Markdown-Extraktion. Der [Agent Skill](agent-skill.md) bringt Coding-Agenten bei, diesen Code selbst zu schreiben.
diff --git a/docs/locales/de/ai/mcp-server.md b/docs/locales/de/ai/mcp-server.md
new file mode 100644
index 0000000..e8d7071
--- /dev/null
+++ b/docs/locales/de/ai/mcp-server.md
@@ -0,0 +1,510 @@
+---
+title: "Scrapling-MCP-Server: Einrichtung und Datenextraktion"
+description: "Verbinden Sie einen KI-Client mit Scrapling für HTTP- und Browser-Scraping. Nutzen Sie Sitzungen, gespeicherten Anmeldestatus, Browser-Aktionen, gezielte Extraktion und den API-Verlauf."
+---
+
+# Anleitung zum MCP-Server von Scrapling {#scrapling-mcp-server-guide}
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/qyFk3ZNwOxE?si=3FHzgcYCb66iJ6e3" title="YouTube-Videoplayer" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+Der **MCP-Server von Scrapling** stellt die Web-Scraping-Funktionen von Scrapling direkt in Ihrem KI-Chatbot oder KI-Agenten bereit. So können Sie im Gespräch Websites abrufen, Daten extrahieren und Bot-Schutz umgehen. Das funktioniert in Claude und jeder anderen Oberfläche, die MCP unterstützt.
+
+## Funktionen {#features}
+
+Der MCP-Server von Scrapling bietet sechzehn Werkzeuge für Web Scraping und Browser-Aktionen. Werkzeuge für Einzelaufrufe rufen eine URL ab und schließen danach ihren Browser oder Client. Sitzungswerkzeuge behalten Cookies und Einstellungen zwischen Aufrufen. So kann die KI im selben Tab weiterarbeiten und den Netzwerkverlauf prüfen.
+
+### Werkzeuge für Einzelaufrufe {#one-shot-tools}
+
+#### 🚀 Einfaches HTTP-Scraping {#basic-http-scraping}
+
+- **`make_request`**: Schnelle HTTP-Anfragen mit beliebiger Methode (GET, POST, PUT, DELETE) und nachgebildetem Browser-Fingerprint. Das Werkzeug erzeugt echte Browser-Header passend zur TLS-Version und unterstützt HTTP/3 sowie weitere Optionen.
+
+#### 🔒 Scraping mit dem Stealthy-Browser {#stealth-browser-scraping}
+
+- **`browser_fetch_once`**: Führt JavaScript aus und extrahiert Daten dynamischer Seiten mit unserem Stealthy-Browser. Es unterstützt das Nachbilden von Fingerprints, das Umgehen von Cloudflare Turnstile und Interstitial sowie die Steuerung von Browser und Anfrage.
+
+### Sitzungswerkzeuge {#session-tools}
+
+#### 🔌 Sitzungen verwalten {#session-management}
+
+- **`browser_open`**: Erstellt eine dauerhafte Stealthy-Browser-Sitzung, die über mehrere `browser_fetch`-Aufrufe hinweg offen bleibt. So muss nicht jedes Mal ein neuer Browser starten. Sie speichert die Browser-Konfiguration und gibt nur `session_id` und `session_type` zurück. Mit `list_sessions` sehen Sie die tatsächlich verwendeten `settings`. Bei CDP-Sitzungen ist dieser Wert leer.
+- **`open_request_session`**: Erstellt eine dauerhafte HTTP-Sitzung ohne Browser zur Verwendung mit `session_make_request`. Sie behält Cookies, Verbindungen und den Browser-Fingerprint (`impersonate`) zwischen Anfragen. Sie gibt nur `session_id` und `session_type` mit dem Typ `static` zurück. Mit `list_sessions` sehen Sie die tatsächlich verwendeten `settings`.
+- **`close_session`**: Schließt eine dauerhafte Browser- oder HTTP-Sitzung und gibt ihre Ressourcen frei.
+- **`list_sessions`**: Listet alle aktiven Sitzungen mit ihren Details und `settings` auf.
+
+#### Browser-Zustand {#browser-state}
+
+- **`browser_save_state`**: Speichert Cookies, Local Storage und IndexedDB in einer mit Playwright kompatiblen JSON-Datei. So können Sie den Anmeldestatus auch nach dem Ende der Browser-Sitzung wiederverwenden. Eine vorhandene Datei wird beim Speichern ersetzt.
+- **`browser_load_state`**: Lädt eine gespeicherte Datei in eine offene Browser-Sitzung, auch vor dem ersten Seitenaufruf. Der aktuelle gespeicherte Zustand wird ersetzt. Bestehende Tabs bleiben offen und wechseln nicht die Seite. Rufen Sie die Seite ab oder laden Sie sie neu, um die wiederhergestellte Anmeldung zu nutzen.
+
+Die Zustandsdateien liegen auf dem Rechner, auf dem der MCP-Server läuft. Sie enthalten weder `sessionStorage` noch offene Tabs oder Browser-Einstellungen.
+
+#### 🎯 Seiten in einer Sitzung abrufen {#fetching-through-a-session}
+
+- **`browser_fetch`**: Führt JavaScript aus und extrahiert Daten einer URL in einer offenen Stealthy-Browser-Sitzung. Es unterstützt das Nachbilden von Fingerprints und das Umgehen von Cloudflare Turnstile und Interstitial. Es kann auch eine strukturierte Seitenansicht mit Referenzen, Positionen und Größen der Elemente erstellen. Damit kann die KI Bedienelemente erkennen und Mausaktionen planen.
+- **`session_make_request`**: Sendet schnelle HTTP-Anfragen mit beliebiger Methode (GET, POST, PUT, DELETE), nachgebildetem Browser-Fingerprint, passenden Browser-Headern und HTTP/3-Unterstützung. Es verwendet Cookies, Verbindungen und den Browser-Fingerprint einer mit `open_request_session` geöffneten Sitzung erneut.
+
+#### 📸 Screenshots {#screenshots}
+
+- **`browser_screenshot`**: Erstellt einen Screenshot der aktuellen Seite oder eines Elements als PNG oder JPEG, ohne die Seite neu zu laden. Damit lassen sich ausgefüllte Felder, offene Menüs, Diagramme oder Ergebniskarten prüfen. Ein Screenshot eines einzelnen Elements enthält weniger unnötige Inhalte. Das Werkzeug unterstützt den sichtbaren Bereich, die ganze Seite oder ein Element sowie eine einstellbare JPEG-Qualität. Der Screenshot wird als echter Bildinhaltsblock zurückgegeben, den das Modell direkt sehen kann.
+
+#### Inhalt der aktuellen Seite {#current-page-content}
+
+- **`browser_extract`**: Liest die aktuelle Seite oder ein Element als strukturierte Ansicht für die KI, HTML, Markdown oder Text, ohne neu zu laden. Damit lassen sich Ergebnisse nach dem Ausfüllen von Formularen oder dem Nachladen von Inhalten extrahieren. Die Ansichten enthalten Rollen, Namen, Referenzen, Positionen und Größen der Elemente für weitere Aktionen. Eine Regex-Suche gibt passende Zeilen mit nahem Kontext und übergeordneten Knoten zurück.
+
+#### Browser-Aktionen {#browser-actions}
+
+- **`browser_actions`**: Verbindet Mausaktionen, das Ausfüllen von Feldern, Tastenkürzel, Antworten auf Dialoge und Wartebedingungen in einem Aufruf. Es kann Browser-Meldungen und Bestätigungen annehmen oder schließen und Text in Eingabedialoge schreiben. Zum Beispiel: ein Suchfeld ausfüllen, die Suche senden, Ergebnisse abwarten und ein Ergebnis öffnen. Die KI kann bekannte Schritte zusammenfassen und separate Seitenansichten anfordern, wenn sie eine Änderung prüfen muss.
+
+ Zeigen Sie Menüs und Tooltips durch Überfahren mit der Maus an, klicken Sie auf Schaltflächen und Links oder bewegen Sie die Maus über einen verschachtelten Bereich, um dort senkrecht oder waagerecht zu scrollen. Bewegungen und Klicks unterstützen Selektoren, Referenzen aus der Seitenansicht und Koordinaten. Bei Zielelementen wartet das Werkzeug automatisch auf das Element und scrollt es ins Blickfeld. Es unterstützt Bewegungen über mehrere Koordinatenschritte, Links-, Rechts- und Mittelklicks sowie Doppelklicks.
+
+ Wählen Sie Felder überall auf der Seite mit Selektoren oder Referenzen aus. Geben Sie Text ein, aktivieren oder deaktivieren Sie Kontrollkästchen, wählen Sie Optionsfelder und eine oder mehrere native Dropdown-Optionen anhand ihrer sichtbaren Beschriftung. Text kann den bisherigen Inhalt ersetzen, ihn löschen oder an der aktuellen Cursorposition fortsetzen. Tastenkürzel können Text auswählen und löschen, den Fokus wechseln, Formulare absenden oder Menüs schließen. Der langsame Modus tippt ein Zeichen nach dem anderen und macht zufällige Pausen zwischen Zeichen und allen Aktionen.
+
+ Warten Sie auf Ergebnisse, das Verschwinden von Ladeanzeigen oder Ereignisse beim Laden der Seite, bevor die nächste Aktion beginnt. Feste Pausen und das Warten, bis die Netzwerkaktivität zur Ruhe kommt werden ebenfalls unterstützt.
+
+#### JavaScript {#javascript}
+
+- **`browser_evaluate`**: Führt JavaScript auf der aktuellen Seite aus, etwa für eigene Extraktionen, Berechnungen oder Aufgaben, die von der Seite abhängen. Die KI kann Daten aus mehreren Elementen sammeln, den Anwendungszustand lesen oder Seiteninhalte ändern. Das Werkzeug unterstützt asynchrone Skripte und gibt ihre Ergebnisse als JSON zurück.
+
+#### Netzwerkverlauf {#network-history}
+
+- **`browser_network_requests`**: Sucht abgeschlossene Anfragen über Tabs, Seitenaufrufe und Browser-Aktionen hinweg. Finden Sie die API-Aufrufe hinter den Daten einer Seite, prüfen Sie HTTP-Fehler und verfolgen Sie gespeicherte Weiterleitungen. Statische Ressourcen werden standardmäßig ausgeblendet, um die Ausgabe klein zu halten. Die Anfragedetails werden als JSON zurückgegeben, bei langen Verläufen auf mehrere Ergebnisseiten verteilt.
+- **`browser_network_request`**: Zeigt die Zusammenfassung, Header, gesendeten Daten oder den textuellen Antwortkörper einer gespeicherten Anfrage als strukturiertes JSON. Der gewählte Teil wird vollständig zurückgegeben, ohne die Seite zu laden oder die Anfrage erneut zu senden. Gespeicherte Antworten bleiben nach einem Seitenwechsel verfügbar. Größenlimits begrenzen den Verlauf. Ein Hinweis erklärt, warum ein Antwortkörper nicht textuell, zu groß oder nicht lesbar ist. Lesen Sie benötigte Details, bevor Sie die MCP-Sitzung schließen.
+
+Antwortkörper werden nur für unterstützte textuelle `Content-Type`-Werte gelesen und gespeichert, zum Beispiel HTML, JSON, XML oder JavaScript. Bei binären, fehlenden oder unbekannten Inhaltstypen werden nur Metadaten und Header der Anfrage behalten. Ihr Antwortkörper wird weder gelesen noch gespeichert. Der Browser lädt Ressourcen weiterhin normal.
+
+Nur abgeschlossene Anfragen werden gespeichert, einschließlich HTTP-Antworten mit 4xx und 5xx. Fehlgeschlagene und noch laufende Anfragen werden ausgelassen. Einträge erscheinen nach Abschluss der Erfassung. Das Lesen des Verlaufs oder Schließen der Sitzung wartet nicht darauf. Erfassungen, die bei einem Seitenwechsel oder beim Schließen noch laufen, können fehlen. Gespeicherte Bytes stammen aus dem Browser und können von den Server-Bytes abweichen. Gültiger Text wird wie bei Playwright als UTF-8 dekodiert. Andernfalls wird die angegebene Zeichenkodierung verwendet.
+
+### Shadow DOM {#shadow-dom}
+
+Setzen Sie `pierce_shadow=true` bei `browser_fetch_once` oder jedem `browser_fetch`-Aufruf, um Inhalte offener Shadow DOMs einzubeziehen. Der Standardwert ist `false`. Im Abschnitt [Shadow DOM](../fetching/stealthy.md#shadow-dom) finden Sie Selektorbeispiele und Einschränkungen.
+
+### Wichtigste Möglichkeiten {#key-capabilities}
+
+- **Inhalte extrahieren**: Wandeln Sie Webseiten oder Elemente in Markdown oder HTML um, oder extrahieren Sie bereinigten Text.
+- **CSS-Selektoren**: Wählen Sie mit Scrapling bestimmte Elemente aus, bevor Sie den Inhalt an die KI übergeben.
+- **Bot-Schutz umgehen**: Bewältigen Sie Cloudflare Turnstile, Interstitial und andere Schutzsysteme.
+- **Proxies**: Verwenden Sie Proxies für Anonymität und Anfragen aus bestimmten Regionen.
+- **Browser nachbilden**: Bilden Sie echte Browser mit TLS-Fingerprint, passenden Browser-Headern und weiteren Optionen nach.
+- **Dauerhafte Sitzungen**: Verwenden Sie Browser-Sitzungen für mehrere Anfragen erneut, um die Leistung zu verbessern.
+- **Werbeblocker**: Alle Browser-Werkzeuge blockieren automatisch Anfragen an etwa 3.500 bekannte Werbe- und Tracking-Domains. Das spart Tokens und beschleunigt das Laden.
+- **Schutz vor Prompt Injection**: Entfernt automatisch versteckte Inhalte, die für Angriffe auf das Modell verwendet werden könnten: durch Inline-Styles versteckte Elemente, aria-hidden, versteckte Slots, Zeichen mit der Breite null, HTML-Kommentare und template-Tags.
+
+#### Warum den MCP-Server von Scrapling statt anderer Werkzeuge verwenden? {#but-why-use-scrapling-mcp-server-instead-of-other-available-tools}
+
+Der Server von Scrapling kann Automatisierung verbergen und Cloudflare Turnstile sowie Interstitial umgehen. Außerdem ist er der einzige Server, mit dem Sie bestimmte Elemente für die KI auswählen können. Das spart viel Zeit und Tokens!
+
+Andere Server extrahieren den Inhalt und übergeben ihn vollständig an die KI, damit sie die gewünschten Felder findet. Dabei verbraucht das Modell viele Tokens für unnötige Inhalte. Mit Scrapling können Sie den Inhalt vor der Übergabe mit einem CSS-Selektor eingrenzen. Das macht den Ablauf schneller und effizienter.
+
+Wenn Sie noch keine CSS-Selektoren schreiben können, ist das kein Problem. Bitten Sie die KI im Prompt, passende Selektoren für die gesuchten Felder zu erstellen. Sie kann verschiedene Kombinationen ausprobieren, bis sie die richtige findet. Wir zeigen das im Abschnitt mit den Beispielen.
+
+## Installation {#installation}
+
+Installieren Sie Scrapling mit MCP-Unterstützung und prüfen Sie, ob auch die Browser-Abhängigkeiten installiert sind.
+
+```bash
+# Install Scrapling with MCP server dependencies
+pip install "scrapling[ai]"
+
+# Install browser dependencies
+scrapling install
+```
+
+Sie können auch das Docker-Image direkt aus der Docker-Registry verwenden:
+```bash
+docker pull pyd4vinci/scrapling
+```
+Oder es aus der GitHub-Registry herunterladen:
+```bash
+docker pull ghcr.io/d4vinci/scrapling:latest
+```
+
+## MCP-Server einrichten {#setting-up-the-mcp-server}
+
+Hier erfahren Sie, wie Sie den MCP-Server von Scrapling zu [Claude Desktop](https://claude.ai/download) und [Claude Code](https://www.anthropic.com/claude-code) hinzufügen. Die gleichen Grundschritte gelten für andere Chatbots, die MCP unterstützen:
+
+!!! note "Hinweis"
+ Der Befehl `scrapling-mcp` in den Beispielen wurde in Version 0.4.13 als Abkürzung für `scrapling mcp` hinzugefügt. Er erleichtert die Nutzung in MCP-Verzeichnissen und Clients, die einen einzelnen Befehl erwarten. Verwenden Sie bei älteren Versionen den Befehl `scrapling` mit `mcp` als erstem Argument.
+
+### Claude Desktop {#claude-desktop}
+
+1. Öffnen Sie Claude Desktop.
+2. Klicken Sie oben links auf das Menü (☰), dann auf Settings → Developer → Edit Config.
+3. Fügen Sie die Konfiguration für den MCP-Server von Scrapling hinzu:
+```json
+"ScraplingServer": {
+ "command": "scrapling-mcp"
+}
+```
+Wenn dies Ihr erster MCP-Server ist, verwenden Sie diesen Dateiinhalt:
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "command": "scrapling-mcp"
+ }
+ }
+}
+```
+Laut dem [offiziellen Artikel](https://modelcontextprotocol.io/quickstart/user) wird dabei eine neue Konfigurationsdatei erstellt, wenn noch keine existiert. Andernfalls wird die vorhandene Datei geöffnet. Sie liegt hier:
+
+1. **MacOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+2. **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+Verwenden Sie den vollständigen Pfad zur ausführbaren Datei `scrapling-mcp`, damit der Start funktioniert. Sie finden ihn mit:
+
+1. **MacOS**: `which scrapling-mcp`
+2. **Windows**: `where scrapling-mcp`
+
+Auf meinem Mac war das Ergebnis `/Users/<MyUsername>/.venv/bin/scrapling-mcp`. Ich habe daher diese Konfiguration verwendet:
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "command": "/Users/<MyUsername>/.venv/bin/scrapling-mcp"
+ }
+ }
+}
+```
+#### Docker {#docker}
+
+Mit dem Docker-Image sieht die Konfiguration etwa so aus:
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "command": "docker",
+ "args": [
+ "run", "-i", "--rm", "pyd4vinci/scrapling", "mcp"
+ ]
+ }
+ }
+}
+```
+
+Das Gleiche gilt für [Cursor](https://cursor.com/docs/context/mcp), [WindSurf](https://windsurf.com/university/tutorials/configuring-first-mcp-server) und andere Clients.
+
+### Claude Code {#claude-code}
+
+Mit [Claude Code](https://www.anthropic.com/claude-code) geht es einfacher:
+
+```bash
+claude mcp add ScraplingServer "/Users/<MyUsername>/.venv/bin/scrapling-mcp"
+```
+So erhalten Sie den Pfad zur ausführbaren Datei von Scrapling:
+
+1. **MacOS**: `which scrapling-mcp`
+2. **Windows**: `where scrapling-mcp`
+
+Weitere Details finden Sie im Artikel von Anthropic zum [Hinzufügen von MCP-Servern zu Claude Code](https://docs.anthropic.com/en/docs/claude-code/mcp#option-1%3A-add-a-local-stdio-server).
+
+Beenden Sie die Anwendung nach dem Hinzufügen des Servers vollständig und starten Sie sie neu. In Claude Desktop sollte unten rechts im Eingabefeld ein MCP-Serversymbol (🔧) erscheinen, oder `ScraplingServer` im Menü `Search and tools` des Eingabefelds.
+
+### Eigene ausführbare Browser-Datei {#custom-browser-executable}
+
+Die Werkzeuge `browser_fetch_once` und `browser_open` können statt des mitgelieferten Chromium eine eigene ausführbare Browser-Datei verwenden, die mit Chromium kompatibel ist. Das eignet sich für angepasste Browser-Versionen oder schlanke Browser-Engines.
+
+Um dies einmal für den gesamten MCP-Server festzulegen, übergeben Sie beim Start den Pfad zur ausführbaren Datei:
+
+```bash
+scrapling-mcp --executable-path "/path/to/chromium"
+```
+
+Fügen Sie die Option in der Konfiguration von Claude Desktop zu den Server-Argumenten hinzu:
+
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "command": "/Users/<MyUsername>/.venv/bin/scrapling-mcp",
+ "args": [
+ "--executable-path",
+ "/path/to/chromium"
+ ]
+ }
+ }
+}
+```
+
+Sie können vor dem Start auch die Umgebungsvariable `SCRAPLING_EXECUTABLE_PATH` setzen. Die KI kann weiterhin eine andere Browser-Datei für einen einzelnen Abruf mit `browser_fetch_once` oder beim Öffnen einer Sitzung mit `browser_open` wählen.
+
+### Mit entfernten Browsern verbinden {#connecting-to-remote-browsers}
+
+`browser_open` muss keinen lokalen Browser starten. Übergeben Sie eine CDP-URL, um über das [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/) eine Verbindung zu einem laufenden Browser herzustellen. Dieser kann auf demselben Rechner, auf einem anderen Rechner oder bei einem Browser-Anbieter laufen:
+```
+Open a stealthy browser session on wss://cdp.provider.example/session/abc123, then use it to scrape the product details from https://shop.example.com. Close the session when you're done.
+```
+Die zurückgegebene `session_id` verwenden Sie wie gewohnt mit `browser_fetch`, `browser_extract`, `browser_actions`, `browser_evaluate`, `browser_screenshot`, `browser_network_requests`, `browser_network_request`, `browser_save_state` und `browser_load_state`.
+
+Die URL kann ein WebSocket-Endpunkt (`ws://`/`wss://`) sein, wie ihn Browser-Dienste bereitstellen. Oder sie kann der HTTP-Endpunkt eines Browsers sein, den Sie selbst mit aktiviertem Remote-Debugging-Port gestartet haben:
+```commandline
+chrome --remote-debugging-port=9222
+```
+Verwenden Sie dafür `cdp_url="http://localhost:9222"` oder die Adresse des anderen Rechners, falls der Browser dort läuft.
+
+!!! note "Hinweise"
+
+ * Da der Browser bereits läuft, ignorieren CDP-Sitzungen Optionen, die nur beim Start gelten: `headless`, `real_chrome` und `executable_path`, einschließlich des oben beschriebenen Server-Standardwerts.<br/>
+ * Alle anderen Optionen gelten weiterhin (`locale`, `useragent`, `proxy`, `cookies`, `timezone_id` usw.). Jede Sitzung erstellt ihren eigenen Browser-Kontext im entfernten Browser.
+
+### Streamable HTTP {#streamable-http}
+
+Seit Version 0.3.6 kann der MCP-Server den Transport 'Streamable HTTP' statt des üblichen 'stdio' verwenden.
+
+Statt dieses Befehls für 'stdio':
+```bash
+scrapling-mcp
+```
+verwenden Sie diesen, um 'Streamable HTTP' zu aktivieren:
+```bash
+scrapling-mcp --http
+```
+Standardmäßig lauscht der Server auf '127.0.0.1' an Port 8000. Sie können beide Werte ändern:
+```bash
+scrapling-mcp --http --host '0.0.0.0' --port 8000
+```
+Die Standardeinstellung akzeptiert nur Verbindungen vom selben Rechner. Mit `--host '0.0.0.0'` machen Sie den Server im Netzwerk erreichbar. Diese Entscheidung ist unabhängig von der unten beschriebenen Authentifizierung.
+
+Wenn Sie 'Streamable HTTP' in Docker ausführen, müssen Sie selbst '0.0.0.0' wählen und ein Token setzen. Sonst erreicht der veröffentlichte Port den Server nicht, weil '127.0.0.1' des Containers nur innerhalb des Containers sichtbar ist:
+```bash
+docker run -p 8000:8000 -e SCRAPLING_MCP_AUTH_TOKEN="<your-token>" pyd4vinci/scrapling mcp --http --host '0.0.0.0'
+```
+
+### Authentifizierung {#authentication}
+
+Auf den Transport 'stdio' kann nur das Programm zugreifen, das ihn gestartet hat. Bei 'Streamable HTTP' kann dagegen jeder, der den Port erreicht, alle Werkzeuge aufrufen. Dazu gehört auch der Abruf beliebiger URLs vom Rechner des Servers aus. Deshalb erfordert 'Streamable HTTP' eine Authentifizierung. Mit `--http` allein startet der Server nicht, sondern verlangt ein Token:
+```bash
+scrapling-mcp --http --auth-token "$(openssl rand -hex 32)"
+```
+Clients müssen dieses Token in einem `Authorization`-Header senden. Anfragen ohne Token werden mit `401` abgewiesen:
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "url": "https://your-server.example.com/mcp",
+ "headers": {
+ "Authorization": "Bearer <your-token>"
+ }
+ }
+ }
+}
+```
+Wenn Sie das Token in der Befehlszeile übergeben, steht es im Shell-Verlauf und in der Prozessliste. Verwenden Sie daher besser die Umgebungsvariable `SCRAPLING_MCP_AUTH_TOKEN`:
+```bash
+export SCRAPLING_MCP_AUTH_TOKEN="<your-token>"
+scrapling-mcp --http
+```
+Wenn Sie einen Server ohne Authentifizierung benötigen, etwa für einen lokalen Test auf der Standardadresse '127.0.0.1', geben Sie dies mit `--no-auth` an:
+```bash
+scrapling-mcp --http --no-auth
+```
+Die Kombination aus `--no-auth` und `--host '0.0.0.0'` macht alle Werkzeuge für jeden erreichbar, der auf den Port zugreifen kann. Vermeiden Sie diese Kombination außerhalb eines vertrauenswürdigen Netzwerks.
+
+Wenn der Server auf einer öffentlichen Adresse lauscht, sollten Sie auch die erlaubten Hostnamen festlegen. Damit aktivieren Sie den Schutz vor DNS-Rebinding. Bei diesem Angriff versucht eine besuchte Website, mit Ihrem Server zu kommunizieren. Sie können die Option mehrfach angeben:
+```bash
+scrapling-mcp --http --allowed-host 'your-server.example.com:8000'
+```
+
+!!! note "Hinweise"
+
+ * Die Authentifizierung gilt nur für 'Streamable HTTP'. Bei 'stdio' wird sie ignoriert, und der Server schreibt eine Warnung ins Log.<br/>
+ * Unverschlüsseltes HTTP sendet das Token im Klartext. Stellen Sie den Server daher hinter einen Reverse Proxy, der die TLS-Verbindung übernimmt, bevor Sie ihn im Internet bereitstellen.<br/>
+ * Es gibt einen gemeinsamen Schlüssel, keine eigenen Zugangsdaten pro Client. Alle Clients verwenden dasselbe Token. Um es zu ändern, müssen Sie den Server neu starten.<br/>
+ * Beim Start mit `--http --no-auth` schreibt der Server trotzdem eine Warnung über die fehlende Authentifizierung ins Log.<br/>
+ * Wenn Sie `--auth-token` und `--no-auth` gemeinsam übergeben, bleibt das Token erhalten und die Authentifizierung aktiv.
+
+## Beispiele {#examples}
+
+Hier sind einige Prompts, mit denen wir den MCP-Server getestet haben. Ihnen fallen bestimmt noch bessere ein :)
+
+Wir beginnen mit einfachen Prompts und gehen dann zu komplexeren über. Die Beispiele nutzen Claude Desktop. Die gleiche Vorgehensweise gilt auch für andere Clients.
+
+1. **Einfaches Web Scraping**
+
+ Extrahieren Sie den Hauptinhalt einer Webseite als Markdown:
+
+ ```
+ Scrape the main content from https://example.com and convert it to markdown format.
+ ```
+
+ Claude kann mit `make_request` die Seite abrufen und sauberen, lesbaren Inhalt zurückgeben. HTTP-Anfragen verwenden standardmäßig drei Versuche mit einer Sekunde Pause dazwischen. Wenn die Seite JavaScript braucht oder HTTP-Anfragen blockiert, kann die KI stattdessen `browser_fetch_once` verwenden. Beide Werkzeuge schließen ihre eigenen Ressourcen nach dem Aufruf.
+
+ Eine genauere Version desselben Prompts wäre:
+ ```
+ Use regular requests to scrape the main content from https://example.com and convert it to markdown format.
+ ```
+ Damit sagen Sie Claude, welches Werkzeug es verwenden soll. Es muss nicht raten. Manchmal beginnt es mit normalen Anfragen. Manchmal wählt es ohne klaren Grund einen Browser. Geben Sie das Werkzeug möglichst an, um Zeit und Geld zu sparen und gleichbleibende Ergebnisse zu erhalten.
+
+2. **Gezielte Datenextraktion**
+
+ Extrahieren Sie bestimmte Elemente mit CSS-Selektoren:
+
+ ```
+ Get all product titles from https://shop.example.com using the CSS selector '.product-title'. If the request fails, retry up to 5 times every 10 seconds.
+ ```
+
+ Der Server extrahiert nur Elemente, die zum Selektor passen, und gibt sie als strukturierte Liste zurück. In diesem Beispiel habe ich bis zu fünf Versuche bei Verbindungsproblemen verlangt. Die Standardeinstellung reicht aber meist aus.
+
+3. **Daten von Online-Shops sammeln**
+
+ Ein etwas komplexerer Prompt:
+ ```
+ Open a stealthy browser session and visit these e-commerce URLs one at a time:
+ - https://shop1.com/product-a
+ - https://shop2.com/product-b
+ - https://shop3.com/product-c
+
+ Get the product names, prices, and descriptions from each page. Close the session when done.
+ ```
+
+ Claude kann eine Browser-Sitzung wiederverwenden, `browser_fetch` der Reihe nach für jede URL aufrufen und dann die extrahierten Daten auswerten.
+
+4. **Ein fortgeschrittener Ablauf**
+
+ Angenommen, ich möchte alle Actionspiele auf der ersten Seite des PlayStation Store abrufen. Dafür kann ich diesen Prompt verwenden:
+ ```
+ Extract the URLs of all games on this page, then visit each game in order and return a list of all action games: https://store.playstation.com/en-us/pages/browse
+ ```
+ Lassen Sie die KI eine HTTP-Sitzung wiederverwenden. So muss sie keinen Browser starten, wenn die Daten über normale Anfragen erreichbar sind:
+ ```
+ Open an HTTP session, extract the URLs of all games on this page, then fetch each game in order and return a list of all action games. Close the session when done: https://store.playstation.com/en-us/pages/browse
+ ```
+ Wenn Sie CSS-Selektoren schreiben können, grenzen Sie den Inhalt ein, bevor die KI ihn liest:
+ ```
+ Use an HTTP session to extract the URLs of all games on the page below, then fetch each game in order and return a list of all action games.
+ The selector for games in the first page is `[href*="/concept/"]` and the selector for the genre in each game page is `[data-qa="gameInfo#releaseInformation#genre-value"]`.
+ Close the session when done.
+
+ URL: https://store.playstation.com/en-us/pages/browse
+ ```
+
+5. **Daten von einer mit Cloudflare geschützten Website abrufen**
+
+ Wenn Sie vermuten, dass die Website Cloudflare verwendet, sagen Sie es Claude. Dann muss es das nicht selbst herausfinden.
+ ```
+ What's the price of this product? Be cautious, as it utilizes Cloudflare's Turnstile protection. Make the browser visible while you work.
+
+ https://ao.com/product/oo101uk-ninja-woodfire-outdoor-pizza-oven-brown-99357-685.aspx
+ ```
+
+6. **Ein langer Ablauf**
+
+ Sie können zum Beispiel einen Prompt wie diesen verwenden:
+ ```
+ Extract all product URLs for the following category, then return the prices and details for the first 3 products.
+
+ https://www.arnotts.ie/furniture/bedroom/bed-frames/
+ ```
+ Besser wäre aber dieser:
+ ```
+ Go to the following category URL and extract all product URLs using the CSS selector "a". Then, reuse the session to fetch the first 3 product pages in order and extract each product’s price and details. Close the session when done.
+
+ Keep the output in markdown format to reduce irrelevant content.
+
+ Category URL:
+ https://www.arnotts.ie/furniture/bedroom/bed-frames/
+ ```
+
+7. **Dauerhafte Sitzungen verwenden**
+
+ Verwenden Sie für mehrere Seiten derselben Website eine dauerhafte Browser-Sitzung. So muss nicht für jede Anfrage ein neuer Browser starten:
+ ```
+ Open a stealthy browser session, then use it to scrape the main details from the first 5 product pages on https://shop.example.com. Close the session when you're done.
+ ```
+ Claude erstellt mit `browser_open` eine dauerhafte Browser-Sitzung, ruft darin jede Produktseite mit `browser_fetch` ab und verwendet am Ende `close_session`. Das ist deutlich schneller als ein neuer Browser für jede Seite.
+
+ !!! danger "Gefahr"
+
+ Schließen Sie dauerhafte Sitzungen immer, wenn Sie fertig sind. Sonst bleiben sie offen!
+
+8. **Eine dauerhafte Sitzung für einen langen Ablauf verwenden**
+
+ Ein weiteres langes Beispiel, das Claude zum Nachdenken bringt:
+
+ ```
+ Use Scrapling MCP to do the following in this order:
+
+ 1. Open a stealthy browser session with headless mode off.
+ 2. Go to this page and collect the number of stars: https://github.com/D4Vinci/Scrapling
+ 3. From the README, get the URL that shows the number of downloads and go to it.
+ 4. Get the number of downloads and the top 3 countries from the graph.
+ 5. Prepare a report with the results.
+ 6. Close the browser.
+ ```
+
+Und so weiter. Ihre Kreativität ist gefragt.
+
+## Bewährte Vorgehensweisen {#best-practices}
+
+Hier sind einige technische Tipps für die Nutzung.
+
+### 1. Das passende Werkzeug wählen {#1-choose-the-right-tool}
+
+- **`make_request`**: Schnelle HTTP-Anfragen für eine einzelne Seite oder einen API-Aufruf.
+- **`browser_fetch_once`**: Eine einzelne JavaScript-Seite, dynamische Seite oder geschützte Website, auch mit Cloudflare.
+- **Sitzungswerkzeuge**: Zusammenhängende Anfragen, Browser-Aktionen, Screenshots und Netzwerkverlauf.
+
+### 2. Leistung verbessern {#2-optimize-performance}
+
+- Verwenden Sie eine Sitzung erneut und rufen Sie die URLs der Reihe nach ab.
+- Deaktivieren Sie unnötige Ressourcen.
+- Wählen Sie passende Zeitlimits.
+- Nutzen Sie CSS-Selektoren für gezielte Extraktion.
+
+### 3. Dynamische Inhalte verarbeiten {#3-handle-dynamic-content}
+
+- Nutzen Sie `network_idle` für Single-Page-Anwendungen (SPAs).
+- Setzen Sie `wait_selector`, um auf bestimmte Elemente zu warten.
+- Erhöhen Sie das Zeitlimit bei langsam ladenden Websites.
+
+### 4. Datenqualität {#4-data-quality}
+
+- Verwenden Sie `main_content_only=true`, um den Seitenkörper auszuwählen und zu bereinigen.
+- Wählen Sie einen passenden `extraction_type` für Ihre Aufgabe.
+
+### 5. Schutz vor Prompt Injection {#5-prompt-injection-protection}
+
+Der MCP-Server bereinigt extrahierte Inhalte automatisch, wenn `main_content_only` aktiviert ist. Das ist die Standardeinstellung. Dabei werden versteckte Inhalte entfernt, mit denen bösartige Websites Anweisungen in den KI-Kontext einschleusen könnten:
+
+- **Versteckende Inline-Styles**: `display:none`, `visibility:hidden` und Nullwerte für Deckkraft, Schriftgröße, Höhe, Breite, maximale Höhe und maximale Breite.
+- **Für Barrierefreiheit ausgeblendete Elemente**: `aria-hidden="true"`.
+- **Template-Tags und versteckte Slots**: Elemente mit `<template>` und `<slot hidden>`.
+- **HTML-Kommentare**: `<!-- ... -->`.
+- **Zeichen mit der Breite null**: Unsichtbare Unicode-Zeichen, etwa Leerzeichen ohne Breite.
+
+Dieser Schutz läuft automatisch bei der Extraktion von HTML, Markdown und Text. Behalten Sie den Standardwert `main_content_only=true` für den größtmöglichen Schutz bei.
+
+### 6. Sitzungen verwalten {#6-manage-sessions}
+
+- Verwenden Sie `make_request` oder `browser_fetch_once` für einen einzelnen Abruf. Die Werkzeuge schließen ihre eigenen Ressourcen und hinterlassen keine Sitzung für weitere Aufrufe.
+- Verwenden Sie `browser_open`, um für mehrere Seiten eine dauerhafte Browser-Sitzung zu erstellen. Rufen Sie dann jede Seite mit `browser_fetch` in dieser Sitzung ab.
+- Für mehrere reine HTTP-Anfragen verwenden Sie `open_request_session` und dann `session_make_request` für jede Anfrage. Die Sitzung behält Cookies, Verbindungen und den Browser-Fingerprint (`impersonate`) zwischen Aufrufen, ohne einen Browser zu verwenden.
+- Sitzungen behalten die beim Öffnen gesetzte Konfiguration. Dazu gehören headless, locale, Cookies und Optionen gegen Erkennung für Browser sowie `impersonate` und `proxy` für HTTP-Sitzungen. Optionen einzelner Anfragen wie timeout, wait_selector, network_idle und solve_cloudflare werden bei jedem Aufruf an `browser_fetch`/`session_make_request` übergeben. Ihre Standardwerte stehen in den Werkzeug-Schemas.
+- `browser_fetch` kann Cloudflare-Prüfungen in der offenen Stealthy-Browser-Sitzung lösen.
+- Schließen Sie Sitzungen am Ende immer mit `close_session`, um Ressourcen freizugeben.
+- Prüfen Sie mit `list_sessions`, welche Sitzungen noch aktiv sind und mit welchen `settings` sie erstellt wurden. Diese werden dem KI-Agenten zurückgegeben und sind bei CDP-Sitzungen leer.
+- Übergeben Sie den Werkzeugen zum Öffnen eine eigene `session_id`, um aussagekräftige Namen wie `"search"` oder `"checkout"` zu vergeben. Sonst wird ein zufälliger Hexadezimalwert verwendet. Wenn die gewählte ID schon belegt ist, wird ein Fehler ausgelöst. So erkennen Sie Konflikte frühzeitig.
+
+### 7. Screenshots erstellen {#7-capturing-screenshots}
+
+- `browser_screenshot` erfasst die Seite, die bereits mit `browser_fetch` in einer Stealthy-Browser-Sitzung geöffnet wurde. Es lädt sie nicht neu. So kann die KI ausgefüllte Felder, offene Menüs und andere Ergebnisse ihrer Aktionen prüfen.
+- Das Bild wird als echter `ImageContent`-Block zurückgegeben, sodass das Modell die Seite direkt sieht.
+- Erfassen Sie den sichtbaren Bereich oder die ganze Seite, einschließlich der Inhalte unterhalb des Bildschirms.
+- Erfassen Sie ein einzelnes Feld, Diagramm, eine Karte oder ein Ergebnis, um weniger umgebenden Inhalt zu erhalten. Dafür kann das Zielelement ins Blickfeld gescrollt werden.
+- Wählen Sie PNG für verlustfreie Bilder oder JPEG mit einstellbarer Qualität für kleinere Dateien.
+- Die KI kann mit `browser_actions` vor der Aufnahme auf Inhalte warten oder Aktionen abschließen.
+
+## Rechtliche und ethische Hinweise {#legal-and-ethical-considerations}
+
+⚠️ **Wichtige Regeln:**
+
+- **robots.txt prüfen**: Öffnen Sie `https://website.com/robots.txt`, um die Crawling-Regeln zu lesen.
+- **Anfragelimits beachten**: Überlasten Sie Server nicht mit Anfragen.
+- **Nutzungsbedingungen**: Lesen und beachten Sie die Bedingungen der Website.
+- **Urheberrecht**: Achten Sie die Rechte am geistigen Eigentum.
+- **Datenschutz**: Beachten Sie die Gesetze zum Schutz personenbezogener Daten.
+- **Geschäftliche Nutzung**: Stellen Sie sicher, dass Sie die Daten geschäftlich nutzen dürfen.
+
+---
+
+*Mit ❤️ vom Scrapling-Team erstellt. Viel Erfolg beim Scraping!*
diff --git a/docs/locales/de/api-reference/custom-types.md b/docs/locales/de/api-reference/custom-types.md
new file mode 100644
index 0000000..880128f
--- /dev/null
+++ b/docs/locales/de/api-reference/custom-types.md
@@ -0,0 +1,26 @@
+---
+title: "API-Referenz für TextHandler und AttributesHandler"
+description: "Sehen Sie sich die Werkzeuge für Text, Textlisten und Attribute von Scrapling an: reguläre Ausdrücke, JSON-Konvertierung und Suche nach Werten."
+---
+
+# Referenz für eigene Datentypen {#custom-types-api-reference}
+
+Hier finden Sie die Parameter, Attribute und Methoden der Klassen für die eigenen Datentypen von Scrapling.
+
+Sie können sie direkt importieren:
+
+```python
+from scrapling.core.custom_types import TextHandler, TextHandlers, AttributesHandler
+```
+
+## ::: scrapling.core.custom_types.TextHandler
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.custom_types.TextHandlers
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.custom_types.AttributesHandler
+ handler: python
+ :docstring:
diff --git a/docs/locales/de/api-reference/fetchers.md b/docs/locales/de/api-reference/fetchers.md
new file mode 100644
index 0000000..766b4e2
--- /dev/null
+++ b/docs/locales/de/api-reference/fetchers.md
@@ -0,0 +1,48 @@
+---
+title: "API-Referenz für HTTP- und Browser-Fetcher"
+description: "Sehen Sie sich die APIs von Fetcher, AsyncFetcher, StealthyFetcher und den Sitzungen an: Anfragen, Browsereinstellungen und Rückgabetypen."
+---
+
+# Fetcher-Klassen {#fetchers-classes}
+
+Hier finden Sie die Parameter, Attribute und Methoden aller Fetcher-Klassen.
+
+Sie können sie direkt importieren:
+
+```python
+from scrapling.fetchers import (
+ Fetcher, AsyncFetcher, StealthyFetcher,
+ FetcherSession, AsyncStealthySession, StealthySession
+)
+```
+
+## ::: scrapling.fetchers.Fetcher
+ handler: python
+ :docstring:
+
+## ::: scrapling.fetchers.AsyncFetcher
+ handler: python
+ :docstring:
+
+## ::: scrapling.fetchers.StealthyFetcher
+ handler: python
+ :docstring:
+
+
+## Sitzungsklassen {#session-classes}
+
+### HTTP-Sitzungen {#http-sessions}
+
+## ::: scrapling.fetchers.FetcherSession
+ handler: python
+ :docstring:
+
+### Stealth-Sitzungen {#stealth-sessions}
+
+## ::: scrapling.fetchers.StealthySession
+ handler: python
+ :docstring:
+
+## ::: scrapling.fetchers.AsyncStealthySession
+ handler: python
+ :docstring:
diff --git a/docs/locales/de/api-reference/mcp-server.md b/docs/locales/de/api-reference/mcp-server.md
new file mode 100644
index 0000000..e01c936
--- /dev/null
+++ b/docs/locales/de/api-reference/mcp-server.md
@@ -0,0 +1,96 @@
+---
+title: "API-Referenz für den MCP-Server von Scrapling"
+description: "Sehen Sie sich die Werkzeuge des MCP-Servers sowie seine Modelle für Anfragen, Antworten und Sitzungen zur Datenextraktion mit HTTP oder Browsern an."
+---
+
+# Referenz des MCP-Servers {#mcp-server-api-reference}
+
+Der **MCP-Server von Scrapling** bietet sechzehn Werkzeuge zum Extrahieren von Daten und zur Bedienung des Browsers über das Model Context Protocol (MCP). Binden Sie Scrapling in Assistenten und KI-Agenten ein, um Daten per Gespräch zu extrahieren, mit Funktionen gegen Bot-Erkennung.
+
+Starten Sie den MCP-Server mit diesem Befehl:
+
+```bash
+scrapling mcp
+```
+
+Oder importieren Sie die Serverklasse direkt:
+
+```python
+from scrapling.core.ai import ScraplingMCPServer
+
+server = ScraplingMCPServer()
+server.serve(http=False, host="127.0.0.1", port=8000)
+```
+
+Um Ihre eigene ausführbare Datei eines Chromium-kompatiblen Browsers zu verwenden, übergeben Sie `executable_path`:
+
+```python
+server = ScraplingMCPServer(executable_path="/path/to/chromium")
+```
+
+## Antwortmodell {#response-model}
+
+Die Werkzeuge zum Abrufen von Seiten und für HTTP-Anfragen geben diese Struktur zurück, mit einer Antwort pro Aufruf. Die Werkzeuge zur Sitzungsverwaltung verwenden die folgenden Modelle. `browser_screenshot` gibt ein Bild der Seite oder eines Elements zusammen mit der aktuellen URL als Bild- und Textblöcke zurück. `browser_extract` und `browser_actions` geben einfachen Text zurück. Die beiden Netzwerkwerkzeuge geben strukturiertes JSON über die folgenden Modelle zurück. `browser_evaluate` gibt das Ergebnis als JSON in einem Textblock zurück.
+
+## ::: scrapling.core.ai.server.ResponseModel
+ handler: python
+ :docstring:
+
+## Modelle für Netzwerkanfragen {#network-request-models}
+
+`browser_network_requests` gibt `NetworkRequestsModel` mit `requests`, `next_cursor`, `has_more` und `dropped_count` zurück. Jedes `NetworkRequestInfo` enthält `id`, `url`, `method`, `resource_type` und `status`. Zum Fortsetzen übergeben Sie `next_cursor` als `after_id`. `has_more` zeigt an, ob der aktuelle Verlauf weitere Treffer enthält.
+
+`browser_network_request` gibt `NetworkRequestModel` mit `request_id`, `part`, `data` und `note` zurück. Zusammenfassungen und Header sind Objekte. Der vollständig gespeicherte Inhalt wird als Zeichenkette zurückgegeben, auch wenn die Antwort JSON enthält. `note` erklärt, ob Inhaltsdaten fehlen oder Header unvollständig sind.
+
+## ::: scrapling.core.ai._network_formatting.NetworkRequestInfo
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.ai.server.NetworkRequestsModel
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.ai._network_formatting.NetworkRequestModel
+ handler: python
+ :docstring:
+
+## Sitzungsmodelle {#session-models}
+
+Modellklassen zur Verwaltung von Sitzungen:
+
+## ::: scrapling.core.ai.server.SessionInfo
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.ai.server.SessionCreatedModel
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.ai.server.SessionClosedModel
+ handler: python
+ :docstring:
+
+## Klasse des MCP-Servers {#mcp-server-class}
+
+Die Hauptklasse des MCP-Servers bietet diese Werkzeuge:
+
+- **`make_request`**: Ruft eine URL über HTTP ab, bildet einen Browser nach und schließt den Client automatisch. Unterstützt GET, POST, PUT und DELETE.
+- **`browser_fetch_once`**: Ruft eine URL mit einem Stealth-Browser ab, führt JavaScript aus, behandelt Cloudflare und schließt den Browser. Nutzen Sie eine dauerhafte Sitzung, wenn Sie danach Aktionen ausführen oder den Netzwerkverlauf lesen möchten.
+
+- **`browser_extract`**: Liest die aktuelle Seite oder ein Element als strukturierte Ansicht für KI, HTML, Markdown oder Text, ohne neu zu laden. Ergebnisse von Formularen und Aktionen bleiben erhalten. Die strukturierten Ansichten enthalten Rollen, Namen, Referenzen, Positionen und Größen der Elemente. Die Suche mit regulären Ausdrücken liefert passende Zeilen, den nahen Kontext und Elternknoten.
+- **`browser_actions`**: Verknüpft Mausbewegungen, Bewegen des Zeigers über Elemente, Klicks, Scrollen, Feldeingaben, Tastenkürzel, Antworten auf Dialoge und Wartezeiten in einem Aufruf. Akzeptieren oder schließen Sie Meldungen und Bestätigungen, oder geben Sie Text in Eingabedialoge ein. Sie können ein Suchfeld ausfüllen, die Suche absenden, auf Ergebnisse warten und eines öffnen, ohne einen Aufruf pro Schritt zu machen.
+
+ Bewegungen und Klicks akzeptieren Selektoren, Referenzen aus strukturierten Ansichten oder Koordinaten. Das Werkzeug wartet auf Elemente und scrollt sie in den sichtbaren Bereich. Es unterstützt Bewegungen in Schritten, linke, rechte und mittlere Mausklicks, Doppelklicks und Scrollen in verschachtelten Bereichen.
+
+ Wählen Sie Felder mit Selektoren oder Referenzen aus strukturierten Ansichten. Geben Sie Text ein, aktivieren oder deaktivieren Sie Kontrollkästchen, wählen Sie Optionsfelder und eine oder mehrere Optionen nativer Listen anhand ihrer Beschriftung. Ersetzen oder löschen Sie Text, oder schreiben Sie an der Cursorposition weiter. Tastenkürzel nutzen den aktuellen Fokus. Der langsame Modus fügt zufällige Pausen zwischen Zeichen und Aktionen ein.
+
+ Warten Sie mit Selektoren oder Referenzen aus strukturierten Ansichten auf Inhalte oder Ladeanzeigen. Sie können auch auf Ladeereignisse, das Ende der Netzwerkaktivität oder eine feste Zeitspanne warten.
+
+- **`browser_evaluate`**: Führt JavaScript auf der aktuellen Seite aus, um eigene Daten zu extrahieren, Berechnungen auszuführen, den Anwendungszustand zu lesen oder Inhalte zu ändern. Unterstützt asynchrone Skripte und gibt deren Ergebnisse als JSON zurück.
+- **`browser_network_requests`**: Durchsucht abgeschlossene Browseranfragen über Tabs, Seitenwechsel und Aktionen hinweg. Finden Sie gespeicherte API-Aufrufe, HTTP-Fehler und Weiterleitungen. Statische Ressourcen werden standardmäßig ausgeblendet, um die Ergebnismenge zu verringern. Fehlgeschlagene oder unvollständige Anfragen werden ausgelassen. Gibt strukturierte Daten mit Seiteneinteilung zurück.
+- **`browser_network_request`**: Liest die Zusammenfassung, Header, gesendeten Daten oder den Textinhalt einer gespeicherten Anfrage als strukturiertes JSON, ohne die Anfrage zu wiederholen. Gibt den gewählten Teil vollständig zurück. Gespeicherte Antworten bleiben nach Seitenwechseln verfügbar, auch HTTP-Antworten mit 4xx und 5xx. Einträge erscheinen, sobald die Aufzeichnung abgeschlossen ist. Lesen des Verlaufs oder Schließen der Sitzung wartet nicht auf laufende Aufzeichnungen. Diese können bei einem Seitenwechsel oder beim Schließen verloren gehen. Die Bytes stammen von Playwright und können von den vom Server gesendeten Bytes abweichen. Für den Text wird die UTF-8-Dekodierung von Playwright genutzt, wenn sie gültig ist, sonst der angegebene Zeichensatz. Nur Inhalte mit einem unterstützten textbasierten `Content-Type` werden gelesen und gespeichert. Bei binären, fehlenden oder unbekannten Typen bleiben Metadaten und Header erhalten, ohne den Inhalt zu lesen. Das Laden der Seite ändert sich dadurch nicht. Der Verlauf hat Größenlimits. Ein optionaler Hinweis erklärt, ob der Inhalt kein Text ist, zu groß ist oder nicht gelesen werden kann. Lesen Sie benötigte Daten, bevor Sie die MCP-Sitzung schließen.
+- **`browser_fetch`**: Ruft eine Seite in einer offenen Stealth-Browsersitzung ab und extrahiert HTML, Markdown, Text oder eine strukturierte Ansicht. Die Ansicht kann die ganze Seite oder ein Element umfassen und enthält Referenzen, Positionen und Größen für spätere Aktionen.
+
+## ::: scrapling.core.ai.server.ScraplingMCPServer
+ handler: python
+ :docstring:
diff --git a/docs/locales/de/api-reference/proxy-rotation.md b/docs/locales/de/api-reference/proxy-rotation.md
new file mode 100644
index 0000000..6c27818
--- /dev/null
+++ b/docs/locales/de/api-reference/proxy-rotation.md
@@ -0,0 +1,18 @@
+---
+title: "API-Referenz für ProxyRotator"
+description: "Sehen Sie sich ProxyRotator und Strategien zur Auswahl und Rotation von Proxys für HTTP- und Browsersitzungen an."
+---
+
+# Proxy-Rotation {#proxy-rotation}
+
+Mit `ProxyRotator` können Sie Proxys in jedem Fetcher und jeder Sitzung wechseln, auch sicher aus mehreren Threads.
+
+Sie können die Klasse direkt importieren:
+
+```python
+from scrapling.fetchers import ProxyRotator
+```
+
+## ::: scrapling.engines.toolbelt.proxy_rotation.ProxyRotator
+ handler: python
+ :docstring:
diff --git a/docs/locales/de/api-reference/response.md b/docs/locales/de/api-reference/response.md
new file mode 100644
index 0000000..c1a1382
--- /dev/null
+++ b/docs/locales/de/api-reference/response.md
@@ -0,0 +1,18 @@
+---
+title: "API-Referenz für Response"
+description: "Sehen Sie sich Status, Header, Inhalt, Metadaten, Markdown-Konvertierung und follow an. Extrahieren Sie Daten mit den von Selector geerbten Methoden."
+---
+
+# Response-Klasse {#response-class}
+
+Die Klasse `Response` enthält die HTTP-Antworten aller Fetcher. Sie bietet Zugriff auf Status, Header, Inhalt und Cookies sowie einen `Selector` zum Auswerten der Antwort.
+
+So importieren Sie die Klasse `Response`:
+
+```python
+from scrapling.engines.toolbelt.custom import Response
+```
+
+## ::: scrapling.engines.toolbelt.custom.Response
+ handler: python
+ :docstring:
diff --git a/docs/locales/de/api-reference/selector.md b/docs/locales/de/api-reference/selector.md
new file mode 100644
index 0000000..62ccdb2
--- /dev/null
+++ b/docs/locales/de/api-reference/selector.md
@@ -0,0 +1,24 @@
+---
+title: "API-Referenz für Selector und Selectors"
+description: "Sehen Sie sich die Methoden von Selector und Selectors für HTML-Auswertung, Auswahl, Extraktion, Navigation und adaptives Wiederfinden an."
+---
+
+# Selector-Klasse {#selector-class}
+
+`Selector` ist die Hauptklasse von Scrapling zum Auswerten von HTML und Auswählen von Elementen.
+
+Hier finden Sie alle Parameter, Attribute und Methoden von `Selector`.
+
+Sie können `Selector` direkt aus `scrapling` importieren:
+
+```python
+from scrapling.parser import Selector
+```
+
+## ::: scrapling.parser.Selector
+ handler: python
+ :docstring:
+
+## ::: scrapling.parser.Selectors
+ handler: python
+ :docstring:
diff --git a/docs/locales/de/api-reference/spiders.md b/docs/locales/de/api-reference/spiders.md
new file mode 100644
index 0000000..b94b8e6
--- /dev/null
+++ b/docs/locales/de/api-reference/spiders.md
@@ -0,0 +1,42 @@
+---
+title: "API-Referenz für Spider, Anfragen und Ergebnisse"
+description: "Sehen Sie sich Spider-Hooks, Anfragen, Sitzungen, Crawling-Statistiken und Exportmethoden an."
+---
+
+# Spider-Klassen {#spider-classes}
+
+Hier finden Sie die Parameter, Attribute und Methoden der Klassen im Spider-Framework.
+
+Sie können sie direkt importieren:
+
+```python
+from scrapling.spiders import Spider, Request, CrawlResult, SessionManager, Response
+```
+
+## ::: scrapling.spiders.Spider
+ handler: python
+ :docstring:
+
+## ::: scrapling.spiders.Request
+ handler: python
+ :docstring:
+
+## Ergebnisklassen {#result-classes}
+
+## ::: scrapling.spiders.result.CrawlResult
+ handler: python
+ :docstring:
+
+## ::: scrapling.spiders.result.CrawlStats
+ handler: python
+ :docstring:
+
+## ::: scrapling.spiders.result.ItemList
+ handler: python
+ :docstring:
+
+## Sitzungen verwalten {#session-management}
+
+## ::: scrapling.spiders.session.SessionManager
+ handler: python
+ :docstring:
diff --git a/docs/locales/de/assets b/docs/locales/de/assets
new file mode 120000
index 0000000..41aef43
--- /dev/null
+++ b/docs/locales/de/assets
@@ -0,0 +1 @@
+../../assets
\ No newline at end of file
diff --git a/docs/locales/de/benchmarks.md b/docs/locales/de/benchmarks.md
new file mode 100644
index 0000000..058f903
--- /dev/null
+++ b/docs/locales/de/benchmarks.md
@@ -0,0 +1,33 @@
+---
+title: "Leistungstests für HTML-Parser: Scrapling und andere Bibliotheken"
+description: "Vergleichen Sie Scrapling mit anderen Python-Bibliotheken beim Auswerten von HTML, Extrahieren von Text und Suchen ähnlicher Elemente."
+---
+
+# Leistungstests {#performance-benchmarks}
+
+Scrapling zeichnet sich auch durch seine Geschwindigkeit aus. Diese Tests vergleichen seinen Parser mit anderen bekannten Bibliotheken.
+
+### Geschwindigkeit der Textextraktion (5.000 verschachtelte Elemente) {#text-extraction-speed-test-5000-nested-elements}
+
+| # | Bibliothek | Zeit (ms) | Im Vergleich zu Scrapling |
+|---|:-----------------:|:---------:|:------------:|
+| 1 | Scrapling | 1,99 | 1,0x |
+| 2 | Parsel/Scrapy | 2,06 | 1,035 |
+| 3 | Lxml allein | 2,56 | 1,286 |
+| 4 | PyQuery | 23,98 | ~12x |
+| 5 | Selectolax | 197,02 | ~99x |
+| 6 | MechanicalSoup | 1545,15 | ~776,5x |
+| 7 | BS4 mit Lxml | 1562,1 | ~785,0x |
+| 8 | BS4 mit html5lib | 3412,73 | ~1714,9x |
+
+
+### Suche nach ähnlichen Elementen und Text {#element-similarity-text-search-performance}
+
+Die adaptive Elementsuche von Scrapling ist schneller als die Alternativen:
+
+| Bibliothek | Zeit (ms) | Im Vergleich zu Scrapling |
+|-------------|:---------:|:------------:|
+| Scrapling | 2,3 | 1,0x |
+| AutoScraper | 12,58 | 5,47x |
+
+> Jedes Ergebnis ist der Durchschnitt aus 100 gemessenen Durchläufen. Die Methode steht in [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py).
diff --git a/docs/locales/de/cli/extract-commands.md b/docs/locales/de/cli/extract-commands.md
new file mode 100644
index 0000000..51245d4
--- /dev/null
+++ b/docs/locales/de/cli/extract-commands.md
@@ -0,0 +1,325 @@
+---
+title: "Webseiten über die CLI als Markdown, HTML oder Text speichern"
+description: "Speichern Sie mit scrapling extract die Ergebnisse von HTTP-Anfragen oder Browser-Aufrufen. Filtern Sie Inhalte mit CSS, legen Sie Anfrageoptionen fest und wählen Sie das Ausgabeformat."
+---
+
+# Anleitung zum Extraktionsbefehl von Scrapling {#scrapling-extract-command-guide}
+
+**Web Scraping über das Terminal, ohne zu programmieren!**
+
+Mit `scrapling extract` können Sie Inhalte von Websites direkt im Terminal herunterladen und extrahieren, ohne Code zu schreiben. Der Befehl eignet sich für Einsteiger, Forschende und alle, die schnell Daten aus dem Web brauchen.
+
+!!! success "Voraussetzungen"
+
+ 1. Lesen Sie die [Grundlagen der Fetcher](../fetching/choosing.md), um das [Response-Objekt](../fetching/choosing.md#response-object) zu verstehen und einen Fetcher auszuwählen.
+ 2. Lesen Sie die Seite zur [Elementauswahl](../parsing/selection.md), um Elemente in einem [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object) zu finden und zu extrahieren.
+ 3. Lesen Sie die Seite über die [Hauptklassen](../parsing/main_classes.md), um zu erfahren, welche Eigenschaften und Methoden [Response](../fetching/choosing.md#response-object) von [Selector](../parsing/main_classes.md#selector) erbt.
+ 4. Lesen Sie mindestens eine Seite im Fetcher-Abschnitt zu den Anfragen, die Sie hier verwenden werden: [HTTP-Anfragen](../fetching/static.md) oder [Seiten mit einem Browser abrufen](../fetching/stealthy.md).
+
+## Was ist die Befehlsgruppe Extract? {#what-is-the-extract-command-group}
+
+Die Befehlsgruppe enthält einfache Terminal-Werkzeuge mit diesen Funktionen:
+
+- **Webseiten herunterladen** und ihren Inhalt in Dateien speichern.
+- **HTML in lesbare Formate umwandeln**, zum Beispiel Markdown, als HTML behalten oder nur den Text der Seite extrahieren.
+- **Eigene CSS-Selektoren verwenden**, um bestimmte Teile einer Seite zu extrahieren.
+- **HTTP-Anfragen senden und Seiten mit Browsern abrufen**.
+- **Fast alle Optionen anpassen**, die auch im Code verfügbar sind, etwa Header, Cookies und Proxies.
+
+!!! tip "Modus für KI"
+
+ Alle Extraktionsbefehle unterstützen die Option `--ai-targeted`. Wenn sie aktiviert ist, wird nur der Hauptinhalt des Seitenkörpers extrahiert. Außerdem entfernt sie Tags ohne nützlichen Text (script, style, noscript, svg), versteckte Elemente, die für Prompt Injection verwendet werden könnten (durch Inline-Styles versteckte Elemente, aria-hidden, versteckte Slots und template-Tags), Unicode-Zeichen mit der Breite null und HTML-Kommentare. Beim Browser-Befehl (`fetch`) aktiviert sie auch den Werbeblocker. Dieser Modus eignet sich, wenn die Ausgabe für ein KI-Modell bestimmt ist.
+
+## Schnellstart {#quick-start}
+
+- **Eine Webseite herunterladen**
+
+ Laden Sie den Inhalt einer Webseite als sauberen, lesbaren Text herunter:
+ ```bash
+ scrapling extract get "https://example.com" page_content.txt
+ ```
+ Dieser Befehl sendet eine HTTP-GET-Anfrage und speichert den Text der Seite in `page_content.txt`.
+
+- **In anderen Formaten speichern**
+
+ Wählen Sie das Ausgabeformat, indem Sie die Dateiendung ändern:
+ ```bash
+ # Convert the HTML content to Markdown, then save it to the file (great for documentation)
+ scrapling extract get "https://blog.example.com" article.md
+
+ # Save the HTML content as it is to the file
+ scrapling extract get "https://example.com" page.html
+
+ # Save a clean version of the text content of the webpage to the file
+ scrapling extract get "https://example.com" content.txt
+
+ # Or use the Docker image with something like this:
+ docker run -v $(pwd)/output:/output pyd4vinci/scrapling extract get "https://blog.example.com" /output/article.md
+ ```
+
+- **Bestimmte Inhalte extrahieren**
+
+ Alle Befehle können mit `--css-selector` oder `-s` bestimmte Teile einer Seite über CSS-Selektoren extrahieren. Die folgenden Beispiele zeigen dies.
+
+## Verfügbare Befehle {#available-commands}
+
+Mit `scrapling extract --help` erhalten Sie diese Liste der verfügbaren Befehle:
+```bash
+Usage: scrapling extract [OPTIONS] COMMAND [ARGS]...
+
+ Fetch web pages using various fetchers and extract full/selected HTML content as HTML, Markdown, or extract text content.
+
+Options:
+ --help Show this message and exit.
+
+Commands:
+ get Perform a GET request and save the content to a file.
+ post Perform a POST request and save the content to a file.
+ put Perform a PUT request and save the content to a file.
+ delete Perform a DELETE request and save the content to a file.
+ fetch Use StealthyFetcher to fetch content with advanced stealth features.
+```
+
+Im Folgenden gehen wir jeden Befehl durch.
+
+### HTTP-Anfragen {#http-requests}
+
+1. **GET-Anfrage**
+
+ Der häufigste Befehl zum Herunterladen von Website-Inhalten:
+
+ ```bash
+ scrapling extract get [URL] [OUTPUT_FILE] [OPTIONS]
+ ```
+
+ **Beispiele:**
+ ```bash
+ # Basic download
+ scrapling extract get "https://news.site.com" news.md
+
+ # Download with custom timeout
+ scrapling extract get "https://example.com" content.txt --timeout 60
+
+ # Extract only specific content using CSS selectors
+ scrapling extract get "https://blog.example.com" articles.md --css-selector "article"
+
+ # Send a request with cookies
+ scrapling extract get "https://scrapling.requestcatcher.com" content.md --cookies "session=abc123; user=john"
+
+ # Add user agent
+ scrapling extract get "https://api.site.com" data.txt -H "User-Agent: MyBot 1.0"
+
+ # Add multiple headers
+ scrapling extract get "https://site.com" page.html -H "Accept: text/html" -H "Accept-Language: en-US"
+ ```
+ Zeigen Sie die verfügbaren Optionen mit `scrapling extract get --help` an:
+ ```bash
+ Usage: scrapling extract get [OPTIONS] URL OUTPUT_FILE
+
+ Perform a GET request and save the content to a file.
+
+ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.
+
+ Options:
+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)
+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"
+ --timeout INTEGER Request timeout in seconds (default: 30)
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)
+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)
+ --verify / --no-verify Whether to verify SSL certificates (default: True)
+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).
+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+
+ ```
+ Die Optionen funktionieren bei den anderen Anfragebefehlen genauso. Wir müssen sie also nicht erneut erklären.
+
+2. **POST-Anfrage**
+
+ ```bash
+ scrapling extract post [URL] [OUTPUT_FILE] [OPTIONS]
+ ```
+
+ **Beispiele:**
+ ```bash
+ # Submit form data
+ scrapling extract post "https://api.site.com/search" results.html --data "query=python&type=tutorial"
+
+ # Send JSON data
+ scrapling extract post "https://api.site.com" response.txt --json '{"username": "test", "action": "search"}'
+ ```
+ Zeigen Sie die verfügbaren Optionen mit `scrapling extract post --help` an:
+ ```bash
+ Usage: scrapling extract post [OPTIONS] URL OUTPUT_FILE
+
+ Perform a POST request and save the content to a file.
+
+ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.
+
+ Options:
+ -d, --data TEXT Form data to include in the request body (as string, ex: "param1=value1&param2=value2")
+ -j, --json TEXT JSON data to include in the request body (as string)
+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)
+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"
+ --timeout INTEGER Request timeout in seconds (default: 30)
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)
+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)
+ --verify / --no-verify Whether to verify SSL certificates (default: True)
+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).
+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+
+ ```
+
+3. **PUT-Anfrage**
+
+ ```bash
+ scrapling extract put [URL] [OUTPUT_FILE] [OPTIONS]
+ ```
+
+ **Beispiele:**
+ ```bash
+ # Send data
+ scrapling extract put "https://scrapling.requestcatcher.com/put" results.html --data "update=info" --impersonate "firefox"
+
+ # Send JSON data
+ scrapling extract put "https://scrapling.requestcatcher.com/put" response.txt --json '{"username": "test", "action": "search"}'
+ ```
+ Zeigen Sie die verfügbaren Optionen mit `scrapling extract put --help` an:
+ ```bash
+ Usage: scrapling extract put [OPTIONS] URL OUTPUT_FILE
+
+ Perform a PUT request and save the content to a file.
+
+ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.
+
+ Options:
+ -d, --data TEXT Form data to include in the request body
+ -j, --json TEXT JSON data to include in the request body (as string)
+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)
+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"
+ --timeout INTEGER Request timeout in seconds (default: 30)
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)
+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)
+ --verify / --no-verify Whether to verify SSL certificates (default: True)
+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).
+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+ ```
+
+4. **DELETE-Anfrage**
+
+ ```bash
+ scrapling extract delete [URL] [OUTPUT_FILE] [OPTIONS]
+ ```
+
+ **Beispiele:**
+ ```bash
+ # Send data
+ scrapling extract delete "https://scrapling.requestcatcher.com/delete" results.html
+
+ # Send JSON data
+ scrapling extract delete "https://scrapling.requestcatcher.com/" response.txt --impersonate "chrome"
+ ```
+ Zeigen Sie die verfügbaren Optionen mit `scrapling extract delete --help` an:
+ ```bash
+ Usage: scrapling extract delete [OPTIONS] URL OUTPUT_FILE
+
+ Perform a DELETE request and save the content to a file.
+
+ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.
+
+ Options:
+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)
+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"
+ --timeout INTEGER Request timeout in seconds (default: 30)
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)
+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)
+ --verify / --no-verify Whether to verify SSL certificates (default: True)
+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).
+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+ ```
+
+### Seiten mit einem Browser abrufen {#browser-fetching}
+
+Nutzen Sie `fetch` für JavaScript-Seiten, Browser-Automatisierung und geschützte Websites. Der Befehl verwendet `StealthyFetcher` mit allen verfügbaren Optionen gegen Erkennung.
+
+```bash
+scrapling extract fetch "https://scrapling.requestcatcher.com/" content.md --network-idle
+scrapling extract fetch "https://scrapling.requestcatcher.com/" data.txt --wait-selector ".content-loaded"
+scrapling extract fetch "https://scrapling.requestcatcher.com/" page.html --no-headless --disable-resources
+scrapling extract fetch "https://nopecha.com/demo/cloudflare" data.txt --solve-cloudflare --css-selector "#padded_content a"
+scrapling extract fetch "https://site.com" content.md --proxy "http://proxy-server:8080"
+```
+
+Mit `--pierce-shadow` können Sie Inhalte offener Shadow DOMs einbeziehen. Die Option ist standardmäßig ausgeschaltet. `--no-pierce-shadow` schaltet sie ausdrücklich aus. Im Abschnitt [Shadow DOM](../fetching/stealthy.md#shadow-dom) finden Sie Selektorbeispiele und Einschränkungen.
+
+```bash
+scrapling extract fetch "https://example.com" content.md --pierce-shadow
+```
+
+Mit `scrapling extract fetch --help` sehen Sie alle Optionen:
+
+```text
+Usage: scrapling extract fetch [OPTIONS] URL OUTPUT_FILE
+
+ Use StealthyFetcher to fetch content with advanced stealth features.
+
+Options:
+ --headless / --no-headless Run browser in headless mode (default: True)
+ --disable-resources / --enable-resources Drop unnecessary resources for speed boost (default: False)
+ --block-webrtc / --allow-webrtc Block WebRTC entirely (default: False)
+ --solve-cloudflare / --no-solve-cloudflare Solve Cloudflare challenges (default: False)
+ --allow-webgl / --block-webgl Allow WebGL (default: True)
+ --pierce-shadow / --no-pierce-shadow Include open Shadow DOM content (default: False)
+ --network-idle / --no-network-idle Wait for network idle (default: False)
+ --real-chrome/--no-real-chrome If you have a Chrome browser installed on your device, enable this, and the Fetcher will launch an instance of your browser and use it. (default: False)
+ --timeout INTEGER Timeout in milliseconds (default: 30000)
+ --wait INTEGER Additional wait time in milliseconds after page load (default: 0)
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ --wait-selector TEXT CSS selector to wait for before proceeding
+ --hide-canvas / --show-canvas Add noise to canvas operations (default: False)
+ --locale TEXT Specify user locale. Defaults to the system default locale.
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -H, --extra-headers TEXT Extra headers in format "Key: Value" (can be used multiple times)
+ --dns-over-https / --no-dns-over-https Route DNS through Cloudflare's DoH to prevent DNS leaks when using proxies (default: False)
+ --block-ads / --no-block-ads Block requests to known ad and tracker domains (default: False)
+ --executable-path TEXT Path to a custom Chromium-compatible browser executable. Falls back to the SCRAPLING_EXECUTABLE_PATH environment variable when not set.
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+```
+
+## Wann Sie welchen Befehl verwenden sollten {#when-to-use-each-command}
+
+Wenn Sie neu im Web Scraping sind, helfen Ihnen diese Regeln bei der Auswahl:
+
+- Nutzen Sie **`get`** für einfache Websites, Blogs oder Nachrichtenartikel.
+- Nutzen Sie **`fetch`** für JavaScript-Seiten, Browser-Automatisierung oder geschützte Websites, einschließlich Cloudflare.
+
+## Rechtliche und ethische Hinweise {#legal-and-ethical-considerations}
+
+⚠️ **Wichtige Regeln:**
+
+- **robots.txt prüfen**: Öffnen Sie `https://website.com/robots.txt`, um die Crawling-Regeln zu lesen.
+- **Anfragelimits beachten**: Überlasten Sie Server nicht mit Anfragen.
+- **Nutzungsbedingungen**: Lesen und beachten Sie die Bedingungen der Website.
+- **Urheberrecht**: Achten Sie die Rechte am geistigen Eigentum.
+- **Datenschutz**: Beachten Sie die Gesetze zum Schutz personenbezogener Daten.
+- **Geschäftliche Nutzung**: Stellen Sie sicher, dass Sie die Daten geschäftlich nutzen dürfen.
+
+---
+
+*Viel Erfolg beim Scraping! Beachten Sie die Regeln der Websites und alle geltenden Gesetze und Vorschriften.*
diff --git a/docs/locales/de/cli/interactive-shell.md b/docs/locales/de/cli/interactive-shell.md
new file mode 100644
index 0000000..439437f
--- /dev/null
+++ b/docs/locales/de/cli/interactive-shell.md
@@ -0,0 +1,236 @@
+---
+title: "Web Scraping in der interaktiven Shell von Scrapling testen"
+description: "Rufen Sie Seiten ab, testen Sie Selektoren und prüfen Sie Ergebnisse in einer IPython-Shell. Wandeln Sie curl-Befehle um, verwenden Sie frühere Antworten erneut und testen Sie Scraping-Code."
+---
+
+# Anleitung zur interaktiven Shell von Scrapling {#scrapling-interactive-shell-guide}
+
+<script src="https://asciinema.org/a/736339.js" id="asciicast-736339" async data-autoplay="1" data-loop="1" data-cols="225" data-rows="40" data-start-at="00:06" data-speed="1.5" data-theme="tango"></script>
+
+**Eine Web-Scraping-REPL für Entwickler und Data Scientists**
+
+Die interaktive Shell von Scrapling ist eine Umgebung auf Basis von IPython, die für Web Scraping entwickelt wurde. Sie bietet direkten Zugriff auf alle Scrapling-Funktionen, praktische Kurzbefehle, automatische Seitenverwaltung und Werkzeuge wie die Umwandlung von curl-Befehlen.
+
+!!! success "Voraussetzungen"
+
+ 1. Lesen Sie die [Grundlagen der Fetcher](../fetching/choosing.md), um das [Response-Objekt](../fetching/choosing.md#response-object) zu verstehen und einen Fetcher auszuwählen.
+ 2. Lesen Sie die Seite zur [Elementauswahl](../parsing/selection.md), um Elemente in einem [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object) zu finden und zu extrahieren.
+ 3. Lesen Sie die Seite über die [Hauptklassen](../parsing/main_classes.md), um zu erfahren, welche Eigenschaften und Methoden [Response](../fetching/choosing.md#response-object) von [Selector](../parsing/main_classes.md#selector) erbt.
+ 4. Lesen Sie mindestens eine Seite im Fetcher-Abschnitt zu den Anfragen, die Sie hier verwenden werden: [HTTP-Anfragen](../fetching/static.md) oder [Seiten mit einem Browser abrufen](../fetching/stealthy.md).
+
+## Warum die interaktive Shell verwenden? {#why-use-the-interactive-shell}
+
+In der interaktiven Shell können Sie sofort ausprobieren und prüfen. Sie müssen nicht für jeden Versuch ein Skript ändern und neu ausführen. Das ist hilfreich für:
+
+- **Schnelle Prototypen**: Testen Sie Ihre Scraping-Ansätze direkt.
+- **Daten untersuchen**: Durchsuchen Sie Websites interaktiv und extrahieren Sie Daten.
+- **Scrapling lernen**: Probieren Sie Funktionen in Echtzeit aus.
+- **Scraper debuggen**: Gehen Sie Anfragen schrittweise durch und prüfen Sie die Ergebnisse.
+- **Befehle umwandeln**: Wandeln Sie einen curl-Befehl aus den Browser-DevTools mit einer Zeile in eine Fetcher-Anfrage um.
+
+## Erste Schritte {#getting-started}
+
+### Shell starten {#launch-the-shell}
+
+```bash
+# Start the interactive shell
+scrapling shell
+
+# Execute code and exit (useful for scripting)
+scrapling shell -c "get('https://quotes.toscrape.com'); print(len(page.css('.quote')))"
+
+# Set logging level
+scrapling shell --loglevel info
+```
+
+Nach dem Start sehen Sie das Scrapling-Banner und können sofort mit dem Scraping beginnen, wie im Video oben:
+
+```python
+# No imports needed - everything is ready!
+get('https://news.ycombinator.com')
+
+# Explore the page structure
+page.css('a')[:5] # Look at first 5 links
+
+# Refine your selectors
+stories = page.css('.titleline>a')
+len(stories) # 30
+
+# Extract specific data
+for story in stories[:3]:
+ title = story.text
+ url = story['href']
+ print(f"{title}: {url}")
+
+# Try different approaches
+titles = page.css('.titleline>a::text') # Direct text extraction
+urls = page.css('.titleline>a::attr(href)') # Direct attribute extraction
+```
+
+## Eingebaute Kurzbefehle {#built-in-shortcuts}
+
+Die Shell bietet Kurzbefehle, mit denen Sie wiederholten Code vermeiden:
+
+- **`get(url, **kwargs)`** - HTTP-GET-Anfrage (statt `Fetcher.get`).
+- **`post(url, **kwargs)`** - HTTP-POST-Anfrage (statt `Fetcher.post`).
+- **`put(url, **kwargs)`** - HTTP-PUT-Anfrage (statt `Fetcher.put`).
+- **`delete(url, **kwargs)`** - HTTP-DELETE-Anfrage (statt `Fetcher.delete`).
+- **`fetch(url, **kwargs)`** - Abruf mit dem Stealthy-Browser (statt `StealthyFetcher.fetch`).
+
+Die häufigsten Klassen sind ohne Import verfügbar, darunter `Fetcher`, `AsyncFetcher`, `StealthyFetcher` und `Selector`.
+
+### Automatische Seitenverwaltung {#smart-page-management}
+
+Die Shell behält Ihre Anfragen und Seiten im Blick:
+
+- **Zugriff auf die aktuelle Seite**
+
+ `page` und `response` werden automatisch mit der zuletzt abgerufenen Seite aktualisiert:
+
+ ```python
+ get('https://quotes.toscrape.com')
+ # 'page' and 'response' both refer to the last fetched page
+ page.url # 'https://quotes.toscrape.com'
+ response.status # Prints 200; Same as page.status
+ ```
+
+- **Seitenverlauf**
+
+ `pages` enthält die letzten fünf Seiten in einem `Selectors`-Objekt:
+
+ ```python
+ get('https://site1.com')
+ get('https://site2.com')
+ get('https://site3.com')
+
+ # Access last 5 pages
+ len(pages) # `Selectors` object with `page` history -> 3
+ pages[0].url # First page in history -> 'https://site1.com'
+ pages[-1].url # Most recent page -> 'https://site3.com'
+
+ # Work with historical pages
+ for i, old_page in enumerate(pages):
+ print(f"Page {i}: {old_page.url} - {old_page.status}")
+ ```
+
+## Weitere nützliche Befehle {#additional-helpful-commands}
+
+### Seite anzeigen {#page-visualization}
+
+Öffnen Sie abgerufene Seiten in Ihrem Browser:
+
+```python
+get('https://quotes.toscrape.com')
+view(page) # Opens the page HTML in your default browser
+```
+
+### curl-Befehle einbinden {#curl-command-integration}
+
+Die Shell bietet die Funktionen `uncurl` und `curl2fetcher`. Damit wandeln Sie curl-Befehle aus den Browser-DevTools in `Fetcher`-Anfragen um.
+
+Kopieren Sie zunächst eine Anfrage als curl-Befehl:
+
+<img src="../assets/scrapling_shell_curl.png" title="Eine Anfrage aus Chrome als curl-Befehl kopieren" alt="Eine Anfrage aus Chrome als curl-Befehl kopieren" style="width: 70%;"/>
+
+- **curl-Befehl in ein Anfrageobjekt umwandeln**
+
+ ```python
+ curl_cmd = '''curl 'https://scrapling.requestcatcher.com/post' \
+ -X POST \
+ -H 'Content-Type: application/json' \
+ -d '{"name": "test", "value": 123}' '''
+
+ request = uncurl(curl_cmd)
+ request.method # -> 'post'
+ request.url # -> 'https://scrapling.requestcatcher.com/post'
+ request.headers # -> {'Content-Type': 'application/json'}
+ ```
+
+- **curl-Befehl direkt ausführen**
+
+ ```python
+ # Convert and execute in one step
+ curl2fetcher(curl_cmd)
+ page.status # -> 200
+ ```
+
+### IPython-Funktionen {#ipython-features}
+
+Die Shell erbt alle Funktionen von IPython:
+
+```python
+# Magic commands
+%time page = get('https://example.com') # Time execution
+%history # Show command history
+%save filename.py 1-10 # Save commands 1-10 to file
+
+# Tab completion works everywhere
+page.c<TAB> # Shows: css, cookies, headers, etc.
+Fetcher.<TAB> # Shows all Fetcher methods
+
+# Object inspection
+get? # Show get documentation
+```
+
+## Beispiele {#examples}
+
+Hier sind einige mit KI erstellte Beispiele:
+
+#### Daten von Online-Shops sammeln {#e-commerce-data-collection}
+
+```python
+# Start with product listing page
+catalog = get('https://shop.example.com/products')
+
+# Find product links
+product_links = catalog.css('.product-link::attr(href)').getall()
+print(f"Found {len(product_links)} products")
+
+# Sample a few products first
+for link in product_links[:3]:
+ product = get(catalog.urljoin(link))
+ name = product.css('.product-name::text').get('')
+ price = product.css('.price::text').get('')
+ print(f"{name}: {price}")
+
+# Scale up with sessions for efficiency
+from scrapling.fetchers import FetcherSession
+with FetcherSession() as session:
+ products = []
+ for link in product_links:
+ product = session.get(catalog.urljoin(link))
+ products.append({
+ 'name': product.css('.product-name::text').get(''),
+ 'price': product.css('.price::text').get(''),
+ 'url': link
+ })
+```
+
+#### APIs einbinden und testen {#api-integration-and-testing}
+
+```python
+>>> # Test API endpoints interactively
+>>> response = get('https://jsonplaceholder.typicode.com/posts/1')
+>>> response.json()
+{'userId': 1, 'id': 1, 'title': 'sunt aut...', 'body': 'quia et...'}
+
+>>> # Test POST requests
+>>> new_post = post('https://jsonplaceholder.typicode.com/posts',
+... json={'title': 'Test Post', 'body': 'Test content', 'userId': 1})
+>>> new_post.json()['id']
+101
+
+>>> # Test with different data
+>>> updated = put('https://jsonplaceholder.typicode.com/posts/1',
+... json={'title': 'Updated Title'})
+```
+
+## Hilfe erhalten {#getting-help}
+
+Wenn Sie neben der Hilfe im Terminal weitere Unterstützung brauchen, finden Sie sie hier:
+
+- [Scrapling-Dokumentation](https://scrapling.readthedocs.io/en/latest/de/)
+- [Discord-Community](https://discord.gg/EMgGbDceNQ)
+- [GitHub-Issues](https://github.com/D4Vinci/Scrapling/issues)
+
+Das war’s! Viel Erfolg beim Scraping. Mit der Shell wird Web Scraping so einfach wie ein Gespräch.
diff --git a/docs/locales/de/cli/overview.md b/docs/locales/de/cli/overview.md
new file mode 100644
index 0000000..82d2447
--- /dev/null
+++ b/docs/locales/de/cli/overview.md
@@ -0,0 +1,36 @@
+---
+title: "Scrapling-CLI: Daten über das Terminal extrahieren"
+description: "Installieren Sie die Terminal-Werkzeuge von Scrapling. Wählen Sie zwischen Extraktionsbefehlen, der interaktiven Shell und dem MCP-Server und nutzen Sie die passende Anleitung."
+---
+
+# Befehlszeilenschnittstelle {#command-line-interface}
+
+Seit Version 0.3 enthält Scrapling eine Befehlszeilenschnittstelle mit drei Hauptfunktionen:
+
+1. **Interaktive Shell**: Eine Web-Scraping-Shell auf Basis von IPython mit vielen Kurzbefehlen und nützlichen Werkzeugen.
+2. **Extraktionsbefehle**: Extrahieren Sie Daten von Websites über das Terminal, ohne zu programmieren.
+3. **Hilfsbefehle**: Werkzeuge zur Installation und Verwaltung.
+
+```bash
+# Launch interactive shell
+scrapling shell
+
+# Convert the content of a page to markdown and save it to a file
+scrapling extract get "https://example.com" content.md
+
+# Get help for any command
+scrapling --help
+scrapling extract --help
+```
+
+## Voraussetzungen {#requirements}
+
+Für die Werkzeuge in diesem Abschnitt müssen Sie die zusätzliche Abhängigkeitsgruppe `shell` installieren:
+```bash
+pip install "scrapling[shell]"
+```
+Um Seiten mit einem Browser abzurufen, installieren Sie auch die Browser-Abhängigkeiten:
+```bash
+scrapling install
+```
+Dieser Befehl lädt Chromium und seine Systemabhängigkeiten herunter und aktualisiert die TLD-Liste. Für HTTP-Anfragen ist dieser Schritt nicht nötig.
diff --git a/docs/locales/de/development/adaptive_storage_system.md b/docs/locales/de/development/adaptive_storage_system.md
new file mode 100644
index 0000000..8be0bca
--- /dev/null
+++ b/docs/locales/de/development/adaptive_storage_system.md
@@ -0,0 +1,73 @@
+---
+title: "Ein eigenes Speichersystem für adaptives Parsing schreiben"
+description: "Implementieren Sie save und retrieve für Scraplings adaptives Parsing. Erstellen Sie ein Redis-Speichersystem, um Elementeigenschaften zu speichern und abzurufen."
+---
+
+# Ein eigenes Speichersystem schreiben {#writing-your-retrieval-system}
+
+Scrapling verwendet standardmäßig SQLite. Diese Anleitung zeigt, wie Sie ein eigenes Speichersystem für die Elementeigenschaften der Funktion `adaptive` schreiben.
+
+Vielleicht möchten Sie zum Beispiel Firebase verwenden und eine Datenbank zwischen Spidern auf verschiedenen Rechnern teilen. Mit einer solchen Onlinedatenbank können die Spider ihre adaptiven Daten gemeinsam nutzen.
+
+Ihre Speicherklasse muss zuerst drei Anforderungen erfüllen:
+
+1. Sie erbt von der abstrakten Klasse `scrapling.core.storage.StorageSystemMixin` und nimmt das String-Argument `url` an, damit die Logik der Bibliothek erhalten bleibt.
+2. Sie verwendet den Dekorator `functools.lru_cache` über der Klasse, um wie die anderen Klassen dem Singleton-Entwurfsmuster zu folgen.
+3. Sie implementiert die Methoden `save` und `retrieve`, wie in den Typannotationen angegeben:
+ - Die Methode `save` gibt nichts zurück und erhält zwei Argumente von der Bibliothek.
+ * Das erste ist das Element selbst, vom Typ `lxml.html.HtmlElement`. Es muss mit der Funktion `element_to_dict` aus dem Untermodul `scrapling.core.utils._StorageTools` in ein Dictionary umgewandelt werden. So bleibt das Format gleich. Danach speichern Sie es in Ihrer Datenbank.
+ * Das zweite ist ein String mit der Kennung zum späteren Abrufen. Die Kombination dieser Kennung mit dem bei der Initialisierung übergebenen Argument `url` muss für jede Zeile eindeutig sein. Sonst werden die Daten für `adaptive` falsch zugeordnet.
+ - Die Methode `retrieve` erhält die Kennung als String. Zusammen mit der bei der Initialisierung übergebenen `url` ruft sie das Dictionary des Elements aus der Datenbank ab und gibt es zurück. Wenn kein Eintrag vorhanden ist, gibt sie `None` zurück.
+
+> Falls die Schritte noch unklar sind, sehen Sie sich meine SQLite3-Implementierung in der Datei [storage_adaptors](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/storage.py) an.
+
+Wenn Ihre Klasse diese Anforderungen erfüllt, ist der Rest einfach. Soll die Bibliothek in einer Anwendung mit mehreren Threads laufen, muss Ihre Klasse das unterstützen. Die Standardklasse ist threadsicher.
+
+Die abstrakte Klasse enthält auch einige Hilfsfunktionen, die Sie verwenden können. Sehen Sie sich am besten den ausführlich kommentierten [Code](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/storage.py) an :)
+
+
+## Praxisbeispiel: Redis als Speicher {#real-world-example-redis-storage}
+
+Hier ist ein praktisches, von KI erstelltes Beispiel mit Redis:
+
+```python
+import redis
+import orjson
+from functools import lru_cache
+from scrapling.core.storage import StorageSystemMixin
+from scrapling.core.utils import _StorageTools
+
+@lru_cache(None)
+class RedisStorage(StorageSystemMixin):
+ def __init__(self, host='localhost', port=6379, db=0, url=None):
+ super().__init__(url)
+ self.redis = redis.Redis(
+ host=host,
+ port=port,
+ db=db,
+ decode_responses=False
+ )
+
+ def save(self, element, identifier: str) -> None:
+ # Convert element to dictionary
+ element_dict = _StorageTools.element_to_dict(element)
+
+ # Create key
+ key = f"scrapling:{self._get_base_url()}:{identifier}"
+
+ # Store as JSON
+ self.redis.set(
+ key,
+ orjson.dumps(element_dict)
+ )
+
+ def retrieve(self, identifier: str) -> dict | None:
+ # Get data
+ key = f"scrapling:{self._get_base_url()}:{identifier}"
+ data = self.redis.get(key)
+
+ # Parse JSON if exists
+ if data:
+ return orjson.loads(data)
+ return None
+```
diff --git a/docs/locales/de/development/scrapling_custom_types.md b/docs/locales/de/development/scrapling_custom_types.md
new file mode 100644
index 0000000..05d1e7e
--- /dev/null
+++ b/docs/locales/de/development/scrapling_custom_types.md
@@ -0,0 +1,27 @@
+---
+title: "Scraplings Text- und Attributtypen in Ihrem Code verwenden"
+description: "Verwenden Sie TextHandler, TextHandlers und AttributesHandler außerhalb des Parsers. Lernen Sie ihre Python-Basistypen, JSON-Hilfsfunktionen und schreibgeschützten Attribute kennen."
+---
+
+# Scraplings eigene Typen verwenden {#using-scraplings-custom-types}
+
+> Sie können die für Scrapling erstellten Typen auch außerhalb der Bibliothek nutzen. Das ist besser, als ihren Code zu kopieren :)
+
+### Alle aktuellen Typen lassen sich einzeln importieren {#all-current-types-can-be-imported-alone-like-below}
+```python
+from scrapling.core.custom_types import TextHandler, AttributesHandler
+
+somestring = TextHandler('{}')
+parsed = somestring.json()
+somedict_1 = AttributesHandler({'a': 1})
+somedict_2 = AttributesHandler(a=1)
+```
+
+`TextHandler` ist eine Unterklasse von Pythons `str`. Deshalb funktionieren alle üblichen Operationen und Methoden für Python-Strings.
+`parsed` ist das Dictionary `{}`, nicht der String `'{}'`. Prüfen Sie eine Instanz mit `isinstance(somestring, TextHandler)` und eine Klasse mit `issubclass(TextHandler, str)`.
+
+Die Klasse `AttributesHandler` ist eine Unterklasse von `collections.abc.Mapping`. Sie ist unveränderlich, also schreibgeschützt, und erbt dessen Operationen. Auf die übergebenen Daten können Sie später über die Eigenschaft `_data` zugreifen. Diese hat jedoch den Typ `types.MappingProxyType` und ist ebenfalls schreibgeschützt. Sie ist um Bruchteile einer Sekunde schneller als `collections.abc.Mapping`.
+
+Wenn Sie Python noch nicht gut kennen: Die üblichen Operationen und Methoden des Standardtyps `dict` funktionieren auch mit `AttributesHandler`, außer denen, die Daten ändern.
+
+Um Daten aus `AttributesHandler` zu ändern, müssen Sie diese zuerst in ein Dictionary umwandeln, etwa mit der Funktion `dict`. Danach bearbeiten Sie dieses Dictionary außerhalb des Objekts.
diff --git a/docs/locales/de/donate.md b/docs/locales/de/donate.md
new file mode 100644
index 0000000..d024c9a
--- /dev/null
+++ b/docs/locales/de/donate.md
@@ -0,0 +1,37 @@
+---
+title: "Scrapling unterstützen und die Entwicklung fördern"
+description: "Unterstützen Sie Scrapling über GitHub Sponsors oder Buy Me a Coffee. Sehen Sie sich die Werbeangebote und ihre Vorteile an."
+---
+
+# Unterstützung und Werbung {#support-and-advertisement}
+
+Ich entwickle diese Projekte in meiner Freizeit und investiere Geld und Arbeit, um sie der Community kostenlos anzubieten. Ihre Unterstützung hilft mir, Kosten zu decken, meinen Pflichten nachzukommen, die Projekte zu verbessern und neue zu erstellen. Sie finanziert auch meinen Kaffeevorrat.
+
+Sie können mich über [GitHub Sponsors](https://github.com/sponsors/D4Vinci) oder [Buy Me a Coffee](https://buymeacoffee.com/d4vinci) unterstützen.
+
+Vielen Dank! Lernen und entdecken Sie weiter. ❤️
+
+## Werbung {#advertisement}
+Wenn Sie Ihr Unternehmen in unserer Community **bewerben** möchten, sehen Sie sich die [verfügbaren Angebote](https://github.com/sponsors/D4Vinci) an:
+
+### 1. [Silver-Angebot](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=435495) (100 $/Monat) {#1-the-silver-tier-100month}
+Vorteile:
+
+1. Ihr Logo erscheint [oben auf der Scrapling-Seite](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#sponsors).
+2. Dasselbe Logo erscheint [oben auf der PyPI-Seite](https://pypi.org/project/scrapling/) und auf [der Seite des Docker-Images](https://hub.docker.com/r/pyd4vinci/scrapling), wie auf der Projektseite.
+
+### 2. [Gold-Angebot](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=591422) (200 $/Monat) {#2-the-gold-tier-200month}
+Vorteile:
+
+1. Ihr Logo erscheint [oben auf der Scrapling-Seite](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#sponsors).
+2. Dasselbe Logo erscheint [oben auf der PyPI-Seite](https://pypi.org/project/scrapling/) und auf [der Seite des Docker-Images](https://hub.docker.com/r/pyd4vinci/scrapling), wie auf der Projektseite.
+3. Ihr Logo erscheint bei den Hauptsponsoren auf der [Scrapling-Website](https://scrapling.readthedocs.io/en/latest/de/).
+
+### 3. [Platinum-Angebot](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=586646) (300 $/Monat) {#3-the-platinum-tier-300month}
+Vorteile:
+
+1. Ihr Logo erhält einen hervorgehobenen Platz [ganz oben auf der Scrapling-Seite](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#platinum-sponsors), mit einem Absatz von bis zu 25 Wörtern.
+2. Dasselbe Logo erscheint auf [der PyPI-Seite](https://pypi.org/project/scrapling/) und [der Docker-Seite](https://hub.docker.com/r/pyd4vinci/scrapling), wie auf der Projektseite.
+3. Ihr Logo wird bei den Hauptsponsoren auf der [Scrapling-Website](https://scrapling.readthedocs.io/en/latest/de/) hervorgehoben.
+4. Sie erhalten die Partnerrolle auf unserem Discord-Server sowie eine Ankündigung auf Twitter und Discord.
+5. Sie werden am Ende der Hinweise zu jeder Version erwähnt.
\ No newline at end of file
diff --git a/docs/locales/de/fetching/choosing.md b/docs/locales/de/fetching/choosing.md
new file mode 100644
index 0000000..5a72ddb
--- /dev/null
+++ b/docs/locales/de/fetching/choosing.md
@@ -0,0 +1,95 @@
+---
+title: "HTTP-Anfragen oder Browser für Web Scraping auswählen"
+description: "Wählen Sie Fetcher oder StealthyFetcher für Ihre Aufgabe. Erfahren Sie, wann direkte HTTP-Anfragen, JavaScript-Rendering und wiederverwendbare Sitzungen passen."
+---
+
+# Grundlagen der Fetcher {#fetchers-basics}
+
+## Einführung {#introduction}
+Fetcher sind Klassen, mit denen Sie in einer Zeile Anfragen senden oder Seiten abrufen können. Sie bieten viele Funktionen und geben ein [Response](#response-object)-Objekt zurück. Seit v0.3 gibt es für alle Fetcher eigene Klassen, die eine Sitzung offen halten. Ein Browser-Fetcher kann so denselben Browser für alle Anfragen nutzen, statt mehrere Browser zu öffnen. Welche Variante passt, hängt von Ihrem Anwendungsfall ab.
+
+Vor v0.2 war Scrapling nur ein Parser. Die Fetcher kamen dazu, damit die Bibliothek Schritt für Schritt alles abdecken kann, was Sie für Web Scraping brauchen.
+
+> Fetcher sind keine einfachen Wrapper um andere Bibliotheken. Sie nutzen diese Bibliotheken als Engine zum Senden von Anfragen und Abrufen von Seiten. Alle Fetcher bieten Funktionen, die ihre Engines selbst nicht haben. Dabei nutzen sie deren Möglichkeiten vollständig und optimieren sie für Web Scraping.
+
+## Überblick über die Fetcher {#fetchers-overview}
+
+Scrapling bietet HTTP-Fetcher (`Fetcher` und `AsyncFetcher`) und einen Browser-Fetcher (`StealthyFetcher`). Für wiederholte Anfragen gibt es Sitzungsklassen.
+
+Die folgende Tabelle hilft Ihnen bei der Auswahl.
+
+
+| Funktion | Fetcher | StealthyFetcher |
+|--------------------|---------------------------------------------------|--------------------------------------------------------------------------------------------|
+| Relative Geschwindigkeit | 🐇🐇🐇🐇🐇 | 🐇🐇🐇 |
+| Tarnung | ⭐⭐ | ⭐⭐⭐⭐⭐ |
+| Optionen gegen Bot-Erkennung | ⭐⭐ | ⭐⭐⭐⭐⭐ |
+| JavaScript laden | ❌ | ✅ |
+| Speicherbedarf | ⭐ | ⭐⭐⭐ |
+| Besonders geeignet für | Einfaches Scraping, wenn HTTP-Anfragen ausreichen | - Dynamisch geladene Websites <br/>- Kleine Automatisierungen <br/>- Einfache bis komplexe Schutzmaßnahmen |
+| Browser | ❌ | Chromium und Google Chrome |
+| Verwendete Browser-API | ❌ | Playwright |
+| Einrichtung | Einfach | Einfach |
+
+Auf den nächsten Seiten erklären wir die einzelnen Fetcher genauer.
+
+## Parser für alle Fetcher konfigurieren {#parser-configuration-in-all-fetchers}
+Alle Fetcher werden auf dieselbe Weise importiert, wie Sie auf den nächsten Seiten sehen:
+```python
+from scrapling.fetchers import Fetcher, AsyncFetcher, StealthyFetcher
+```
+Danach können Sie den Fetcher direkt verwenden, ohne eine Instanz zu erstellen. Er nutzt die Standardeinstellungen des Parsers:
+```python
+page = StealthyFetcher.fetch('https://example.com')
+```
+Wenn Sie den Parser ([Klasse Selector](../parsing/main_classes.md#selector)) einstellen möchten, der die Antwort vor der Rückgabe verarbeitet, machen Sie zuerst Folgendes:
+```python
+from scrapling.fetchers import Fetcher
+Fetcher.configure(adaptive=True, keep_comments=False) # and the rest
+```
+oder
+```python
+from scrapling.fetchers import Fetcher
+Fetcher.adaptive=True
+Fetcher.keep_comments=False
+```
+Danach setzen Sie Ihren Code wie gewohnt fort.
+
+Die verfügbaren Argumente sind `adaptive`, `adaptive_domain`, `huge_tree`, `keep_comments`, `storage` und `storage_args`. Es sind dieselben wie bei der Klasse [Selector](../parsing/main_classes.md#selector). Mit `<fetcher_class>.display_config()` können Sie die aktuelle Konfiguration jederzeit anzeigen.
+
+!!! info
+
+ Das Argument `adaptive` ist standardmäßig deaktiviert. Sie müssen es aktivieren, um diese Funktion zu nutzen.
+
+### Parser für einzelne Anfragen konfigurieren {#set-parser-config-per-request}
+Die oben gezeigte Konfiguration gilt global für alle Anfragen und Abrufe über diese Klasse. Das hält die Nutzung einfach.
+
+Wenn Sie für jede Anfrage andere Einstellungen brauchen, übergeben Sie der Anfragemethode (`fetch`/`get`/`post`/...) ein Dictionary im Argument `selector_config`.
+
+## Das Response-Objekt {#response-object}
+Das Objekt `Response` basiert auf der Klasse [Selector](../parsing/main_classes.md#selector). Es enthält zusätzlich Angaben zur Antwort, zum Beispiel Header, Status und Cookies:
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://example.com')
+
+page.status # HTTP status code
+page.reason # Status message
+page.cookies # Response cookies as a dictionary
+page.headers # Response headers
+page.request_headers # Request headers
+page.history # Response history of redirections, if any
+page.body # Raw response body as bytes
+page.encoding # Response encoding
+page.meta # Response metadata dictionary (e.g., proxy used). Mainly helpful with the spiders system.
+```
+Alle Fetcher geben ein `Response`-Objekt zurück. Browser-Sitzungen mit `record_requests=True` liefern über `session.network.search(limit=None)` und `session.network.get(request_id)` ebenfalls gespeicherte `Response`-Objekte. Unter [Netzwerkverlauf](stealthy.md#network-history) erfahren Sie mehr über gespeicherte API-Antworten und den Umstieg auf v5.
+
+Das Objekt `Response` kann die Seite auch in einer Zeile in bereinigtes Markdown für LLMs umwandeln:
+```python
+markdown = Fetcher.get('https://example.com').markdown(main_content_only=True)
+```
+Vor der Umwandlung werden immer Skripte, Styles sowie versteckte Inhalte und Inhalte zur Prompt Injection entfernt. Mit `css_selector` können Sie die Umwandlung auf bestimmte Elemente beschränken. Dafür ist das Extra `rag` nötig, das auch in `ai`/`shell`/`all` enthalten ist. Die Seite [RAG-Systeme erstellen](../ai/building-rag-systems.md) erklärt die Details.
+
+!!! note
+
+ Anders als bei der Klasse [Selector](../parsing/main_classes.md#selector) ist der Antwortinhalt der Klasse `Response` seit v0.4 immer vom Typ bytes.
diff --git a/docs/locales/de/fetching/static.md b/docs/locales/de/fetching/static.md
new file mode 100644
index 0000000..b6f2518
--- /dev/null
+++ b/docs/locales/de/fetching/static.md
@@ -0,0 +1,449 @@
+---
+title: "HTTP-Scraping mit Python, Fetcher und FetcherSession"
+description: "Senden Sie synchrone oder asynchrone HTTP-Anfragen mit Browser-Imitation, Cookies, Proxys und wiederverwendbaren Sitzungen. Lesen Sie mit Scrapling Daten aus der Antwort aus."
+---
+
+# HTTP-Anfragen {#http-requests}
+
+Die Klasse `Fetcher` sendet schnelle HTTP-Anfragen mit geringem Ressourcenbedarf. Sie nutzt die leistungsfähige Bibliothek `curl_cffi` und bietet viele Funktionen gegen Bot-Erkennung.
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Grundlagen der Fetcher](../fetching/choosing.md) gelesen. Sie wissen, was ein [Response-Objekt](../fetching/choosing.md#response-object) ist und welchen Fetcher Sie verwenden möchten.
+ 2. Sie haben die Seite [Elemente auswählen](../parsing/selection.md) gelesen und wissen, wie Sie Elemente in einem [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object)-Objekt finden und extrahieren.
+ 3. Sie haben die Seite [Hauptklassen](../parsing/main_classes.md) gelesen und kennen die Eigenschaften und Methoden, die [Response](../fetching/choosing.md#response-object) von [Selector](../parsing/main_classes.md#selector) erbt.
+
+## Grundlegende Verwendung {#basic-usage}
+Sie importieren diesen Fetcher auf dieselbe Weise wie alle anderen Fetcher:
+
+```python
+from scrapling.fetchers import Fetcher
+```
+Wie Sie die Parser-Optionen einstellen, erfahren Sie [hier](choosing.md#parser-configuration-in-all-fetchers).
+
+### Gemeinsame Argumente {#shared-arguments}
+Alle Methoden zum Senden von Anfragen teilen einige Argumente. Diese erklären wir zuerst.
+
+- **url**: Die Ziel-URL.
+- **stealthy_headers**: Erzeugt und ergänzt echte Browser-Header, einschließlich eines Google-Referer-Headers. Standardmäßig aktiviert.
+- **follow_redirects**: Steuert Weiterleitungen. **Der Standardwert `"safe"`** folgt Weiterleitungen, lehnt aber Ziele mit internen oder privaten IP-Adressen ab. Das schützt vor SSRF. Mit `True` folgen Sie allen Weiterleitungen ohne Einschränkung. Mit `False` deaktivieren Sie sie vollständig.
+- **timeout**: Maximale Wartezeit in Sekunden für den Abschluss jeder Anfrage. **Standardwert: 30 Sekunden**.
+- **retries**: Maximale Anzahl der Versuche für fehlgeschlagene Anfragen, einschließlich des ersten Versuchs. **Standardwert: 3**.
+- **retry_delay**: Wartezeit in Sekunden zwischen erneuten Versuchen. **Standardwert: 1 Sekunde**.
+- **impersonate**: Imitiert den TLS-Fingerprint bestimmter Browser. Nimmt einen Browsernamen oder eine Liste an, etwa `"chrome110"`, `"firefox102"`, `"safari15_5"` für bestimmte Versionen. Mit `"chrome"`, `"firefox"`, `"safari"` oder `"edge"` wird die neueste verfügbare Version genutzt. So sehen die Anfragen auf TLS-Ebene aus wie die eines echten Browsers. Bei einer Liste wird für jede Anfrage zufällig ein Eintrag gewählt. **Standardwert: die neueste verfügbare Chrome-Version.**
+- **http3**: Verwendet HTTP/3 für die Anfragen. **Standardwert: False**. Zusammen mit `impersonate` kann dies Probleme verursachen.
+- **cookies**: Cookies für die Anfrage. Möglich sind ein Dictionary mit `name→value` oder eine Liste von Dictionarys.
+- **proxy**: Leitet den gesamten HTTP- und HTTPS-Verkehr dieser Anfrage über einen Proxy. Das Format ist `http://username:password@localhost:8030`.
+- **proxy_auth**: HTTP-Basic-Authentifizierung für den Proxy als Tupel (username, password).
+- **proxies**: Dictionary mit den zu verwendenden Proxys. Format: `{"http": proxy_url, "https": proxy_url}`.
+- **proxy_rotator**: Eine `ProxyRotator`-Instanz für den automatischen Proxy-Wechsel. Kann nicht mit `proxy` oder `proxies` kombiniert werden.
+- **headers**: Header für die Anfrage. Sie können alle durch `stealthy_headers` erzeugten Header überschreiben.
+- **max_redirects**: Maximale Anzahl der Weiterleitungen. **Standardwert: 30**. Mit -1 gibt es keine Begrenzung.
+- **verify**: Legt fest, ob HTTPS-Zertifikate geprüft werden. **Standardwert: True**.
+- **cert**: Tupel (cert, key) mit den Dateinamen des Client-Zertifikats und seines Schlüssels.
+- **selector_config**: Dictionary mit eigenen Parser-Argumenten zum Erstellen des endgültigen `Selector`/`Response`-Objekts.
+
+!!! note "Hinweise:"
+
+ 1. Derzeit können diese Browser imitiert werden: (`"edge"`, `"chrome"`, `"chrome_android"`, `"safari"`, `"safari_beta"`, `"safari_ios"`, `"safari_ios_beta"`, `"firefox"`, `"tor"`)<br/>
+ 2. Die verfügbaren Browser und Versionen erscheinen automatisch in der Autovervollständigung des Arguments. Sie werden mit jedem Update von `curl_cffi` aktualisiert.<br/>
+ 3. Wenn `impersonate` oder `stealthy_headers` aktiviert ist, erzeugen die Fetcher automatisch echte Browser-Header passend zur verwendeten Browserversion.
+
+Für weitere Anpassungen können Sie jeder Methode außerdem die von `curl_cffi` unterstützten Argumente übergeben, die sie nicht bereits selbst anbietet.
+
+### Zeichenkodierung {#text-encoding}
+
+Wenn der Text einer Seite ohne UTF-8-Kodierung falsch dargestellt wird, übergeben Sie `default_encoding="shift_jis"` oder die tatsächliche Kodierung der Seite. Diese wird verwendet, wenn der Header `Content-Type` keinen Zeichensatz nennt. Ein vom Server angegebener Zeichensatz wird damit nicht überschrieben.
+
+Wenn der Server einen falschen Zeichensatz angibt, erzwingen Sie die richtige Kodierung mit `selector_config={"encoding": "shift_jis"}`.
+
+### HTTP-Methoden {#http-methods}
+Je nach Methode gibt es weitere Argumente, etwa `params` für GET-Anfragen und `data`/`json` für POST-, PUT- und DELETE-Anfragen.
+
+Die Beispiele zeigen es am besten:
+
+> Hinweis: Die Methoden `OPTIONS` und `HEAD` werden nicht unterstützt.
+#### GET {#get}
+```python
+from scrapling.fetchers import Fetcher
+# Basic GET
+page = Fetcher.get('https://example.com')
+page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
+page = Fetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')
+# With parameters
+page = Fetcher.get('https://example.com/search', params={'q': 'query'})
+
+# With headers
+page = Fetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})
+# Basic HTTP authentication
+page = Fetcher.get("https://example.com", auth=("my_user", "password123"))
+# Browser impersonation
+page = Fetcher.get('https://example.com', impersonate='chrome')
+# HTTP/3 support
+page = Fetcher.get('https://example.com', http3=True)
+```
+Für asynchrone Anfragen ist nur eine kleine Änderung nötig:
+```python
+from scrapling.fetchers import AsyncFetcher
+# Basic GET
+page = await AsyncFetcher.get('https://example.com')
+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')
+# With parameters
+page = await AsyncFetcher.get('https://example.com/search', params={'q': 'query'})
+# With headers
+page = await AsyncFetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})
+# Basic HTTP authentication
+page = await AsyncFetcher.get("https://example.com", auth=("my_user", "password123"))
+# Browser impersonation
+page = await AsyncFetcher.get('https://example.com', impersonate='chrome110')
+# HTTP/3 support
+page = await AsyncFetcher.get('https://example.com', http3=True)
+```
+Das Objekt `page` ist dabei immer ein [Response](choosing.md#response-object)-Objekt und damit auch ein [Selector](../parsing/main_classes.md#selector). Sie können es also direkt verwenden:
+```python
+page.css('.something.something')
+
+page = Fetcher.get('https://api.github.com/events')
+>>> page.json()
+[{'id': '<redacted>',
+ 'type': 'PushEvent',
+ 'actor': {'id': '<redacted>',
+ 'login': '<redacted>',
+ 'display_login': '<redacted>',
+ 'gravatar_id': '',
+ 'url': 'https://api.github.com/users/<redacted>',
+ 'avatar_url': 'https://avatars.githubusercontent.com/u/<redacted>'},
+ 'repo': {'id': '<redacted>',
+...
+```
+#### POST {#post}
+```python
+from scrapling.fetchers import Fetcher
+# Basic POST
+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, params={'q': 'query'})
+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)
+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")
+# Another example of form-encoded data
+page = Fetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)
+# JSON data
+page = Fetcher.post('https://example.com/api', json={'key': 'value'})
+```
+Für asynchrone Anfragen ist nur eine kleine Änderung nötig:
+```python
+from scrapling.fetchers import AsyncFetcher
+# Basic POST
+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})
+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)
+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")
+# Another example of form-encoded data
+page = await AsyncFetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)
+# JSON data
+page = await AsyncFetcher.post('https://example.com/api', json={'key': 'value'})
+```
+#### PUT {#put}
+```python
+from scrapling.fetchers import Fetcher
+# Basic PUT
+page = Fetcher.put('https://example.com/update', data={'status': 'updated'})
+page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")
+page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')
+# Another example of form-encoded data
+page = Fetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})
+```
+Für asynchrone Anfragen ist nur eine kleine Änderung nötig:
+```python
+from scrapling.fetchers import AsyncFetcher
+# Basic PUT
+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'})
+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")
+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')
+# Another example of form-encoded data
+page = await AsyncFetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})
+```
+
+#### DELETE {#delete}
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.delete('https://example.com/resource/123')
+page = Fetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")
+page = Fetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')
+```
+Für asynchrone Anfragen ist nur eine kleine Änderung nötig:
+```python
+from scrapling.fetchers import AsyncFetcher
+page = await AsyncFetcher.delete('https://example.com/resource/123')
+page = await AsyncFetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")
+page = await AsyncFetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')
+```
+
+## Sitzungen verwalten {#session-management}
+
+Für mehrere Anfragen mit derselben Konfiguration verwenden Sie `FetcherSession`. Die Klasse funktioniert in synchronem und asynchronem Code. Sie erkennt die benötigte Sitzungsart automatisch, ohne dass Sie eine andere Klasse importieren müssen.
+
+`FetcherSession` nimmt fast alle Argumente der Anfragemethoden an. So legen Sie die Konfiguration für die gesamte Sitzung fest und können einzelne Anfragen bei Bedarf anders konfigurieren, wie die folgenden Beispiele zeigen.
+
+```python
+from scrapling.fetchers import FetcherSession
+
+# Create a session with default configuration
+with FetcherSession(
+ impersonate='chrome',
+ http3=True,
+ stealthy_headers=True,
+ timeout=30,
+ retries=3
+) as session:
+ # Make multiple requests with the same settings and the same cookies
+ page1 = session.get('https://scrapling.requestcatcher.com/get')
+ page2 = session.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})
+ page3 = session.get('https://api.github.com/events')
+
+ # All requests share the same session and connection pool
+```
+
+Mit `ProxyRotator` und `FetcherSession` wechseln Sie den Proxy automatisch zwischen Anfragen:
+
+```python
+from scrapling.fetchers import FetcherSession, ProxyRotator
+
+rotator = ProxyRotator([
+ 'http://proxy1:8080',
+ 'http://proxy2:8080',
+ 'http://proxy3:8080',
+])
+
+with FetcherSession(proxy_rotator=rotator, impersonate='chrome') as session:
+ # Each request automatically uses the next proxy in rotation
+ page1 = session.get('https://example.com/page1')
+ page2 = session.get('https://example.com/page2')
+
+ # You can check which proxy was used via the response metadata
+ print(page1.meta['proxy'])
+```
+
+Für eine einzelne Anfrage können Sie den Sitzungs-Proxy oder den Rotator mit `proxy=` direkt in der Anfragemethode überschreiben:
+
+```python
+with FetcherSession(proxy='http://default-proxy:8080') as session:
+ # Uses the session proxy
+ page1 = session.get('https://example.com/page1')
+
+ # Override the proxy for this specific request
+ page2 = session.get('https://example.com/page2', proxy='http://special-proxy:9090')
+```
+
+Ein asynchrones Beispiel:
+
+```python
+async with FetcherSession(impersonate='firefox', http3=True) as session:
+ # All standard HTTP methods available
+ response = await session.get('https://example.com')
+ response = await session.post('https://scrapling.requestcatcher.com/post', json={'data': 'value'})
+ response = await session.put('https://scrapling.requestcatcher.com/put', data={'update': 'info'})
+ response = await session.delete('https://scrapling.requestcatcher.com/delete')
+```
+Oder besser:
+```python
+import asyncio
+from scrapling.fetchers import FetcherSession
+
+# Async session usage
+async with FetcherSession(impersonate="safari") as session:
+ urls = ['https://example.com/page1', 'https://example.com/page2']
+
+ tasks = [
+ session.get(url) for url in urls
+ ]
+
+ pages = await asyncio.gather(*tasks)
+```
+
+Die Klasse `Fetcher` nutzt `FetcherSession`, um für jede Anfrage eine vorübergehende Sitzung zu erstellen.
+
+### Vorteile von Sitzungen {#session-benefits}
+
+- **Deutlich schneller**: Zehnmal schneller, als für jede Anfrage eine eigene Sitzung zu erstellen.
+- **Cookies behalten**: Automatische Cookie-Verwaltung über mehrere Anfragen hinweg.
+- **Ressourcen sparen**: Weniger Speicher- und CPU-Bedarf bei mehreren Anfragen.
+- **Zentrale Konfiguration**: Alle Anfrageeinstellungen an einer Stelle verwalten.
+
+## Beispiele {#examples}
+Einige ausführliche Beispiele für den Einstieg in Web Scraping.
+
+### Einfache HTTP-Anfrage {#basic-http-request}
+
+```python
+from scrapling.fetchers import Fetcher
+
+# Make a request
+page = Fetcher.get('https://example.com')
+
+# Check the status
+if page.status == 200:
+ # Extract title
+ title = page.css('title::text').get()
+ print(f"Page title: {title}")
+
+ # Extract all links
+ links = page.css('a::attr(href)').getall()
+ print(f"Found {len(links)} links")
+```
+
+### Produkte auslesen {#product-scraping}
+
+```python
+from scrapling.fetchers import Fetcher
+
+def scrape_products():
+ page = Fetcher.get('https://example.com/products')
+
+ # Find all product elements
+ products = page.css('.product')
+
+ results = []
+ for product in products:
+ results.append({
+ 'title': product.css('.title::text').get(),
+ 'price': product.css('.price::text').re_first(r'\d+\.\d{2}'),
+ 'description': product.css('.description::text').get(),
+ 'in_stock': product.has_class('in-stock')
+ })
+
+ return results
+```
+
+### Dateien herunterladen {#downloading-files}
+
+```python
+from scrapling.fetchers import Fetcher
+
+page = Fetcher.get('https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/main_cover.png')
+with open(file='main_cover.png', mode='wb') as f:
+ f.write(page.body)
+```
+
+### Mehrere Ergebnisseiten durchlaufen {#pagination-handling}
+
+```python
+from scrapling.fetchers import Fetcher
+
+def scrape_all_pages():
+ base_url = 'https://example.com/products?page={}'
+ page_num = 1
+ all_products = []
+
+ while True:
+ # Get current page
+ page = Fetcher.get(base_url.format(page_num))
+
+ # Find products
+ products = page.css('.product')
+ if not products:
+ break
+
+ # Process products
+ for product in products:
+ all_products.append({
+ 'name': product.css('.name::text').get(),
+ 'price': product.css('.price::text').get()
+ })
+
+ # Next page
+ page_num += 1
+
+ return all_products
+```
+
+### Formulare absenden {#form-submission}
+
+```python
+from scrapling.fetchers import Fetcher
+
+# Submit login form
+response = Fetcher.post(
+ 'https://example.com/login',
+ data={
+ 'username': '[email protected]',
+ 'password': 'password123'
+ }
+)
+
+# Check login success
+if response.status == 200:
+ # Extract user info
+ user_name = response.css('.user-name::text').get()
+ print(f"Logged in as: {user_name}")
+```
+
+### Tabellen auslesen {#table-extraction}
+
+```python
+from scrapling.fetchers import Fetcher
+
+def extract_table():
+ page = Fetcher.get('https://example.com/data')
+
+ # Find table
+ table = page.css('table')[0]
+
+ # Extract headers
+ headers = [
+ th.text for th in table.css('thead th')
+ ]
+
+ # Extract rows
+ rows = []
+ for row in table.css('tbody tr'):
+ cells = [td.text for td in row.css('td')]
+ rows.append(dict(zip(headers, cells)))
+
+ return rows
+```
+
+### Navigationsmenü {#navigation-menu}
+
+```python
+from scrapling.fetchers import Fetcher
+
+def extract_menu():
+ page = Fetcher.get('https://example.com')
+
+ # Find navigation
+ nav = page.css('nav')[0]
+
+ menu = {}
+ for item in nav.css('li'):
+ links = item.css('a')
+ if links:
+ link = links[0]
+ menu[link.text] = {
+ 'url': link['href'],
+ 'has_submenu': bool(item.css('.submenu'))
+ }
+
+ return menu
+```
+
+## Wann eignet sich dieser Fetcher? {#when-to-use}
+
+Verwenden Sie `Fetcher`, wenn Sie:
+
+- schnelle HTTP-Anfragen brauchen.
+- den zusätzlichen Ressourcenbedarf klein halten möchten.
+- kein JavaScript ausführen müssen, weil sich die Website über HTTP-Anfragen auslesen lässt.
+- einige Funktionen gegen Bot-Erkennung brauchen, etwa für Websites mit Schutzmaßnahmen ohne JavaScript-Prüfungen.
+
+Verwenden Sie `FetcherSession`, wenn Sie:
+
+- mehrere Anfragen an dieselbe oder verschiedene Websites senden.
+- Cookies und Anmeldedaten zwischen Anfragen behalten müssen.
+- Verbindungen wiederverwenden möchten, um die Leistung zu verbessern.
+- dieselbe Konfiguration für mehrere Anfragen brauchen.
+- mit APIs arbeiten, die einen Sitzungszustand benötigen.
+
+Verwenden Sie andere Fetcher, wenn Sie:
+
+- einen Browser automatisieren müssen.
+- erweiterte Funktionen gegen Bot-Erkennung brauchen.
+- JavaScript ausführen oder mit dynamischen Inhalten interagieren müssen.
diff --git a/docs/locales/de/fetching/stealthy.md b/docs/locales/de/fetching/stealthy.md
new file mode 100644
index 0000000..98e8606
--- /dev/null
+++ b/docs/locales/de/fetching/stealthy.md
@@ -0,0 +1,536 @@
+---
+title: "JavaScript-Websites mit StealthyFetcher auslesen"
+description: "Laden Sie Seiten mit JavaScript, warten Sie auf Daten und nutzen Sie Anmeldungen in Scrapling-Browser-Sitzungen weiter. Lesen Sie API-Antworten aus und konfigurieren Sie Proxys und Schutzprüfungen."
+---
+
+# Seiten mit StealthyFetcher im Browser abrufen {#browser-fetching-with-stealthyfetcher}
+
+Die Klasse `StealthyFetcher` lädt JavaScript-Seiten und automatisiert Chromium oder Google Chrome mit Funktionen gegen Bot-Erkennung. Sie nutzt die [Playwright-API](https://playwright.dev/python/docs/intro) mit Anpassungen zur Tarnung.
+
+Zum Automatisieren der Seite brauchen Sie einige Kenntnisse der [Page-API von Playwright](https://playwright.dev/python/docs/api/class-page). Darauf kommen wir später zurück.
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Grundlagen der Fetcher](../fetching/choosing.md) gelesen. Sie wissen, was ein [Response-Objekt](../fetching/choosing.md#response-object) ist und welchen Fetcher Sie verwenden möchten.
+ 2. Sie haben die Seite [Elemente auswählen](../parsing/selection.md) gelesen und wissen, wie Sie Elemente in einem [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object)-Objekt finden und extrahieren.
+ 3. Sie haben die Seite [Hauptklassen](../parsing/main_classes.md) gelesen und kennen die Eigenschaften und Methoden, die [Response](../fetching/choosing.md#response-object) von [Selector](../parsing/main_classes.md#selector) erbt.
+
+## Grundlegende Verwendung {#basic-usage}
+Sie importieren diesen Fetcher auf dieselbe Weise wie alle anderen Fetcher:
+
+```python
+from scrapling.fetchers import StealthyFetcher
+```
+Wie Sie die Parser-Optionen einstellen, erfahren Sie [hier](choosing.md#parser-configuration-in-all-fetchers).
+
+Wir gehen die meisten Argumente einzeln mit Beispielen durch. Eine schnelle Übersicht finden Sie in der [vollständigen Tabelle der Argumente](#full-list-of-arguments).
+
+!!! abstract "Zusammenfassung"
+
+ Die asynchrone Variante von `fetch` heißt `async_fetch`.
+
+
+Dieser Fetcher bietet drei grundlegende Betriebsarten, die Sie nach Bedarf kombinieren können.
+
+Das sind:
+
+### 1. Mitgeliefertes Chromium {#1-bundled-chromium}
+```python
+StealthyFetcher.fetch('https://example.com')
+```
+Dies öffnet das mitgelieferte Chromium mit den Standardeinstellungen zur Tarnung und lädt die Seite.
+
+### 2. Echtes Chrome {#2-real-chrome}
+```python
+StealthyFetcher.fetch('https://example.com', real_chrome=True)
+```
+Nutzen Sie diese Option, wenn Google Chrome installiert ist. Sie funktioniert wie die erste Variante, verwendet aber Ihr installiertes Google Chrome statt Chromium. Dadurch wirken die Anfragen echter und lassen sich schwerer als automatisiert erkennen.
+
+Wenn Sie Google Chrome noch nicht installiert haben, können Sie es mit diesem Terminalbefehl für die Bibliothek installieren:
+```commandline
+playwright install chrome
+```
+
+### 3. CDP-Verbindung {#3-cdp-connection}
+```python
+StealthyFetcher.fetch('https://example.com', cdp_url='ws://localhost:9222')
+```
+Statt Chromium oder Google Chrome lokal zu starten, können Sie sich über das [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/) mit einem entfernten Browser verbinden.
+
+Die URL kann ein WebSocket-Endpunkt sein (`ws://`/`wss://`), wie ihn Browser-Dienste bereitstellen. Auch der HTTP-Endpunkt eines Browsers ist möglich, etwa `http://localhost:9222`.
+
+
+## Was kann der Fetcher? {#what-does-it-do}
+
+StealthyFetcher bietet diese Funktionen gegen Bot-Erkennung:
+
+1. Mit `solve_cloudflare=True` umgeht er automatisch alle Arten von Cloudflare-Turnstile- und Interstitial-Prüfungen.
+2. Er verhindert verräterische Spuren der CDP-Runtime und WebRTC-Lecks.
+3. Er isoliert die JavaScript-Ausführung, entfernt viele Playwright-Fingerprints und verhindert die Erkennung anhand bestimmter bekannter Bot-Verhaltensweisen.
+4. Er ergänzt zufälliges Canvas-Rauschen, um Fingerprinting über Canvas zu verhindern.
+5. Er passt bekannte Merkmale automatisch an, anhand derer der Headless-Modus erkannt wird. Außerdem bietet er eine Option gegen die Erkennung durch abweichende Zeitzonen.
+6. Dazu kommen weitere Optionen gegen Schutzmaßnahmen.
+
+## Alle Argumente {#full-list-of-arguments}
+Dieser Fetcher und seine Sitzungsklassen bieten viele Optionen. Vor den [Beispielen](#examples) sehen Sie hier die vollständige Liste:
+
+
+| Argument | Beschreibung | Optional |
+|:---------------------:|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------:|
+| url | Ziel-URL. | ❌ |
+| headless | Mit `True` läuft der Browser ohne sichtbares Fenster (**Standard**), mit `False` mit sichtbarem Fenster. | ✔️ |
+| disable_resources | Blockiert unnötige Ressourcen, um das Laden zu beschleunigen. Betroffen sind `font`, `image`, `media`, `beacon`, `object`, `imageset`, `texttrack`, `websocket`, `csp_report` und `stylesheet`. | ✔️ |
+| cookies | Cookies für die nächste Anfrage. | ✔️ |
+| useragent | Zu verwendende User-Agent-Zeichenkette. **Ohne Angabe erzeugt und verwendet der Fetcher einen echten User-Agent desselben Browsers und derselben Version.** | ✔️ |
+| network_idle | Wartet, bis die Seite mindestens 500 ms lang keine Netzwerkverbindungen mehr hat. | ✔️ |
+| load_dom | Wartet, bis das gesamte JavaScript der Seite geladen und ausgeführt wurde, also auf den Zustand `domcontentloaded`. Standardmäßig aktiviert. | ✔️ |
+| pierce_shadow | Nimmt offene Shadow-DOM-Inhalte in das HTML der Antwort auf. Standardwert: `False`. Kann für die Sitzung festgelegt und pro Anfrage überschrieben werden. | ✔️ |
+| timeout | Maximale Wartezeit in Millisekunden für alle Operationen und Wartevorgänge auf der Seite. Standardwert: 30.000 ms, also 30 Sekunden. | ✔️ |
+| wait | Zusätzliche Wartezeit in Millisekunden nach Abschluss aller Schritte, bevor der Fetcher die Seite schließt und das `Response`-Objekt zurückgibt. | ✔️ |
+| page_action | Funktion zur Automatisierung. Sie erhält das `page`-Objekt und führt nach der Navigation die gewünschten Aktionen aus. | ✔️ |
+| page_setup | Funktion, die das `page`-Objekt erhält und vor der Navigation läuft. Registrieren Sie damit Event-Listener oder Routen, die vor dem Laden der Seite bereitstehen müssen. | ✔️ |
+| wait_selector | Wartet, bis ein bestimmter CSS-Selektor den angegebenen Zustand erreicht. | ✔️ |
+| init_script | Absoluter Pfad einer JavaScript-Datei, die beim Erstellen jeder Seite dieser Sitzung ausgeführt wird. | ✔️ |
+| wait_selector_state | Zustand, auf den Scrapling für den mit `wait_selector` angegebenen Selektor wartet. _Standardwert: `attached`._ | ✔️ |
+| google_search | Setzt einen Google-Referer-Header. Standardmäßig aktiviert. | ✔️ |
+| extra_headers | Dictionary mit zusätzlichen Headern für die Anfrage. _Der Referer aus `google_search` hat Vorrang vor dem hier gesetzten Referer, wenn Sie beide verwenden._ | ✔️ |
+| proxy | Proxy für die Anfragen. Möglich sind eine Zeichenkette oder ein Dictionary mit ausschließlich den Schlüsseln 'server', 'username' und 'password'. | ✔️ |
+| real_chrome | Aktivieren Sie diese Option, wenn Chrome auf Ihrem Gerät installiert ist. Der Fetcher startet und verwendet dann diesen Browser. | ✔️ |
+| locale | Regionale Einstellungen, etwa `en-GB` oder `de-DE`. Sie beeinflussen `navigator.language`, den Anfrage-Header `Accept-Language` sowie Zahlen- und Datumsformate. Standardmäßig werden die Systemeinstellungen verwendet. | ✔️ |
+| timezone_id | Ändert die Zeitzone des Browsers. Standardwert: die Zeitzone des Systems. | ✔️ |
+| cdp_url | Verbindet sich mit dieser CDP-URL, um einen bestehenden Browser über CDP zu steuern, statt eine neue Instanz zu starten. | ✔️ |
+| user_data_dir | Pfad zum Benutzerprofilordner mit Browser-Sitzungsdaten wie Cookies und lokalem Speicher. Standardmäßig wird ein temporärer Ordner erstellt. **Nur mit Sitzungen nutzbar.** | ✔️ |
+| extra_flags | Liste zusätzlicher Browser-Optionen für den Start. | ✔️ |
+| solve_cloudflare | Löst alle Arten von Cloudflare-Turnstile- und Interstitial-Prüfungen, bevor die Antwort zurückgegeben wird. Standardwert: `False`. | ✔️ |
+| block_webrtc | Zwingt WebRTC, die Proxy-Einstellungen zu beachten, um die lokale IP-Adresse nicht offenzulegen. | ✔️ |
+| hide_canvas | Ergänzt zufälliges Rauschen bei Canvas-Operationen, um Fingerprinting zu verhindern. | ✔️ |
+| allow_webgl | Standardmäßig aktiviert. Beim Deaktivieren werden WebGL und WebGL 2.0 vollständig abgeschaltet. Das ist nicht empfohlen, weil viele WAFs prüfen, ob WebGL aktiv ist. | ✔️ |
+| additional_args | Zusätzliche Einstellungen für den Playwright-Kontext. Sie haben Vorrang vor den Scrapling-Einstellungen. | ✔️ |
+| selector_config | Dictionary mit eigenen Parser-Argumenten zum Erstellen des endgültigen `Selector`/`Response`-Objekts. | ✔️ |
+| blocked_domains | Menge von Domains, an die keine Anfragen gesendet werden. Auch Subdomains werden erfasst: `"example.com"` blockiert zum Beispiel `"sub.example.com"`. | ✔️ |
+| block_ads | Blockiert Anfragen an etwa 3.500 bekannte Werbe- und Tracking-Domains. Kann mit `blocked_domains` kombiniert werden. | ✔️ |
+| dns_over_https | Leitet DNS-Anfragen über Cloudflares DNS-over-HTTPS, um DNS-Lecks bei der Proxy-Nutzung zu verhindern. | ✔️ |
+| proxy_rotator | Eine `ProxyRotator`-Instanz für den automatischen Proxy-Wechsel. Kann nicht mit `proxy` kombiniert werden. | ✔️ |
+| retries | Anzahl erneuter Versuche bei fehlgeschlagenen Anfragen. Standardwert: 3. | ✔️ |
+| retry_delay | Wartezeit in Sekunden zwischen erneuten Versuchen. Standardwert: 1. | ✔️ |
+| record_requests | Speichert abgeschlossene Anfragen und Antworten in `session.network`. Nur für Sitzungen. Standardwert: `False`. | ✔️ |
+| max_recorded_requests | Maximale Anzahl gespeicherter Anfrageeinträge pro Sitzung. Standardwert: 1.000. Für gespeicherte Antwortinhalte gelten außerdem feste Größenlimits. | ✔️ |
+| executable_path | Absoluter Pfad zu einer eigenen Browserdatei statt des mitgelieferten Chromium. Hilfreich bei besonderen Installationen oder eigenen Browser-Builds. | ✔️ |
+
+In Sitzungsklassen können Sie all diese Argumente für die gesamte Sitzung festlegen. Einstellungen auf Tab-Ebene lassen sich zusätzlich pro Anfrage anpassen. Dazu gehören `google_search`, `timeout`, `wait`, `page_action`, `page_setup`, `extra_headers`, `disable_resources`, `wait_selector`, `wait_selector_state`, `network_idle`, `load_dom`, `pierce_shadow`, `solve_cloudflare`, `blocked_domains`, `proxy` und `selector_config`.
+
+!!! note "Hinweise:"
+
+ 1. Mit `disable_resources` waren Anfragen an einige Websites in meinen Tests etwa 25 % schneller. Die Option kann auch Proxy-Datenverkehr sparen. Verwenden Sie sie aber mit Bedacht: Manche Websites werden damit nie vollständig geladen.
+ 2. `google_search` ist für alle Anfragen standardmäßig aktiviert und setzt den Referer auf `https://www.google.com/`. Es hat Vorrang vor einem Referer in `extra_headers`.
+ 3. Ohne eigenen User-Agent erzeugt der Fetcher im Headless-Modus einen echten User-Agent derselben Browserversion. Bei sichtbarem Browser nutzt er dessen Standard-User-Agent. Dieser entspricht in aktuellen Versionen dem eines normalen Browsers.
+ 4. `init_script` wird im Browser-Kontext registriert und beim Erstellen von Seiten ausgeführt. Der Stealth-Modus verwendet standardmäßig den isolierten Ausführungskontext von Patchright. Wenn Ihre `page_action`-Funktion globale Werte lesen muss, die das Skript auf `window` setzt, rufen Sie darin `page.evaluate(..., isolated_context=False)` auf.
+
+## Sitzungen verwalten {#session-management}
+
+Mit `StealthySession`/`AsyncStealthySession` bleibt der Browser für mehrere Anfragen mit derselben Konfiguration offen. Diese Klassen nehmen alle Argumente von `fetch` an. So legen Sie die Einstellungen für die gesamte Sitzung fest.
+
+```python
+from scrapling.fetchers import StealthySession
+
+
+with StealthySession(
+ headless=True,
+ disable_resources=True,
+ real_chrome=True
+) as session:
+
+ page1 = session.fetch('https://example1.com')
+ page2 = session.fetch('https://example2.com')
+ page3 = session.fetch('https://dynamic-site.com')
+
+
+```
+
+### Asynchrone Sitzungen nutzen {#async-session-usage}
+
+```python
+import asyncio
+from scrapling.fetchers import AsyncStealthySession
+
+async def scrape_multiple_sites():
+ async with AsyncStealthySession(
+ network_idle=True,
+ timeout=30000,
+ max_pages=3
+ ) as session:
+
+ pages = await asyncio.gather(
+ session.fetch('https://spa-app1.com'),
+ session.fetch('https://spa-app2.com'),
+ session.fetch('https://dynamic-content.com')
+ )
+ return pages
+```
+
+Das Argument `max_pages` begrenzt die Anzahl der gleichzeitig offenen Tabs in einem **Pool von Browser-Tabs**. Nach einer Anfrage bleiben die Tabs offen. Bei jeder neuen Anfrage geht die Bibliothek so vor:
+
+1. Sie verwendet einen freien Tab, falls einer vorhanden ist. Jede Anfrage setzt ihre eigenen Tab-Einstellungen wie `timeout`, `extra_headers`, `disable_resources` und `blocked_domains`. So werden keine Einstellungen der vorherigen Anfrage übernommen.
+2. Andernfalls öffnet sie einen neuen Tab, wenn weniger als `max_pages` Tabs offen sind.
+3. Sonst prüft sie in Abständen von weniger als einer Sekunde, ob ein Tab frei wird. Nach 60 Sekunden löst sie `TimeoutError` aus. Das kann passieren, wenn die aufgerufene Website nicht mehr reagiert.
+
+Tabs mit Fehlern werden geschlossen und ersetzt. Mit `session.close_pages()` können Sie jederzeit alle offenen Tabs schließen. Die nächste Anfrage öffnet dann einen neuen.
+
+So können mehrere URLs gleichzeitig im selben Browser geladen werden. Das spart viele Ressourcen und ist vor allem schnell :)
+
+Da die Tabs offen bleiben, ist die zuletzt geladene Seite bei der nächsten Anfrage noch vorhanden. Eine `page_setup`-Funktion dieser Anfrage läuft auf der alten Seite, bevor die Navigation beginnt. So können Sie Automatisierungsschritte über mehrere Anfragen verketten.
+
+Die Versionen 0.3.2 bis 0.4.14 schlossen jeden Tab nach seiner Anfrage, weil Einstellungen bei der Wiederverwendung auf andere Anfragen übergingen. Seit 0.4.15 werden sie bei jeder Wiederverwendung zurückgesetzt. Deshalb bleiben die Tabs jetzt offen.
+
+### Sitzungszustand speichern und laden {#save-and-load-session-state}
+
+Mit `save_state(path)` speichern Sie Cookies, lokalen Speicher und IndexedDB in einer JSON-Datei. Mit `load_state(path)` laden Sie die Datei in einer anderen Sitzung oder ersetzen den gespeicherten Zustand der aktuellen Sitzung. Beide Methoden nehmen eine Zeichenkette oder `pathlib.Path` an und geben `None` zurück. Das Format ist mit den Speicherzustandsdateien von Playwright kompatibel.
+
+```python
+from scrapling.fetchers import StealthySession
+
+with StealthySession() as session:
+ session.fetch('https://example.com')
+ session.save_state('state.json')
+
+with StealthySession() as session:
+ session.load_state('state.json')
+ page = session.fetch('https://example.com')
+```
+
+Speichern Sie nach Abschluss der Anmeldung oder anderer Browser-Aktionen. Rufen Sie beide Methoden in einer gestarteten Sitzung auf, nachdem laufende Abrufe beendet sind. Das Laden ersetzt vorhandene Cookies, lokalen Speicher und IndexedDB. Laden Sie eine Seite neu oder rufen Sie sie ab, um die wiederhergestellte Anmeldung zu nutzen. Bestehende Tabs navigieren beim Laden des Zustands nicht automatisch.
+
+Bei `AsyncStealthySession` verwenden Sie `await`:
+
+```python
+from scrapling.fetchers import AsyncStealthySession
+
+async def restore_session():
+ async with AsyncStealthySession() as session:
+ await session.load_state('state.json')
+ page = await session.fetch('https://example.com')
+ await session.save_state('state.json')
+ return page
+```
+
+Diese Methoden speichern und laden nur den gemeinsamen Browser-Kontext. Temporäre Proxy-Kontexte einzelner Anfragen bleiben unberührt. Sitzungen mit `proxy_rotator` haben keinen gemeinsamen Kontext. Daher lösen die Methoden dort `RuntimeError` aus. Ein fester Sitzungs-`proxy` funktioniert wie gewohnt.
+
+Die Datei enthält weder `sessionStorage` noch offene Tabs oder Browser-Einstellungen. Beim Speichern wird sie überschrieben. Ihr übergeordneter Ordner muss vorhanden sein. Datei- und JSON-Fehler werden an den aufrufenden Code weitergegeben.
+
+### Vorteile von Sitzungen {#session-benefits}
+
+- **Browser wiederverwenden**: Weitere Anfragen sind deutlich schneller, weil dieselbe Browser-Instanz genutzt wird.
+- **Cookies behalten**: Cookies und Sitzungszustand werden wie in einem normalen Browser automatisch verwaltet.
+- **Gleicher Fingerprint**: Alle Anfragen nutzen denselben Browser-Fingerprint.
+- **Speicher sparen**: Geringerer Ressourcenbedarf, als für jeden Abruf einen neuen Browser zu starten.
+
+
+## Beispiele {#examples}
+Mit Beispielen wird die Verwendung leichter verständlich.
+
+### Ressourcen steuern {#resource-control}
+
+```python
+
+page = StealthyFetcher.fetch('https://example.com', disable_resources=True)
+```
+
+### Shadow DOM {#shadow-dom}
+
+Manche Seiten speichern Inhalte in offenen Shadow-Roots. Diese fehlen im normalen HTML der Seite. Aktivieren Sie `pierce_shadow`, um sie in die Antwort aufzunehmen. Danach können Sie wie gewohnt CSS- oder XPath-Selektoren nutzen:
+
+```python
+from scrapling.fetchers import StealthyFetcher
+
+page = StealthyFetcher.fetch('https://example.com', pierce_shadow=True)
+titles = page.css('product-card .title::text').getall()
+```
+
+Die Option ist standardmäßig `False`. Sie können sie auch für eine Sitzung aktivieren und für eine einzelne Anfrage deaktivieren:
+
+```python
+from scrapling.fetchers import StealthySession
+
+with StealthySession(pierce_shadow=True) as session:
+ page = session.fetch('https://example.com')
+ plain_page = session.fetch('https://example.com', pierce_shadow=False)
+```
+
+Dieselbe Option funktioniert mit `async_fetch` und asynchronen Sitzungen.
+
+Es werden nur offene Shadow-Roots erfasst. Geschlossene Shadow-Roots und iframe-Dokumente werden nicht durchlaufen. Nutzen Sie `wait_selector`, wenn eine Komponente erst nach der Seite geladen wird.
+
+Jeder offene Shadow-Root wird in der Antwort von einem `<shadow-root>`-Element umschlossen. Slots behalten ihre Tags und Attribute. Sie enthalten ihre zugewiesenen Knoten oder den Ersatzinhalt, wenn nichts zugewiesen ist. Nicht zugewiesene Kinder aus dem Light DOM werden weggelassen. Die echte Browser-Seite bleibt unverändert.
+
+```html
+<product-card>
+ <shadow-root>
+ <div class="title">Product name</div>
+ <slot name="price"><span class="price">20</span></slot>
+ </shadow-root>
+</product-card>
+```
+
+Nachfahren-Selektoren funktionieren auch über diese Elemente hinweg. Selektoren für direkte Kinder müssen die zusätzlichen Elemente und Slots berücksichtigen:
+
+```python
+titles = page.css('product-card .title::text').getall()
+titles = page.css('product-card > shadow-root > .title::text').getall()
+prices = page.css('product-card > shadow-root > slot[name="price"] > .price::text').getall()
+```
+
+Diese Elemente und Slots erscheinen in XPath-Pfaden, `.children`, `response.body` und HTML-Exporten. Markdown- und Textextraktion geben ihren Inhalt ohne die Tags zurück. Slot-Attribute, die Inhalte verbergen, bleiben für die Inhaltsbereinigung verfügbar.
+
+Die Momentaufnahme folgt der Inhaltsreihenfolge, berechnet aber weder CSS-Sichtbarkeit noch Layout. Selektoren mit `<shadow-root>` gelten für die Scrapling-Antwort, nicht für die echte Browser-Seite. Andere HTML-Parser können ungewöhnliche Verschachtelungen anders behandeln.
+
+### Domains blockieren {#domain-blocking}
+
+```python
+
+page = StealthyFetcher.fetch('https://example.com', blocked_domains={"ads.example.com", "tracker.net"})
+```
+
+### Netzwerk steuern {#network-control}
+
+```python
+
+page = StealthyFetcher.fetch('https://example.com', network_idle=True)
+
+
+page = StealthyFetcher.fetch('https://example.com', timeout=30000)
+
+
+page = StealthyFetcher.fetch('https://example.com', proxy='http://username:password@host:port')
+```
+
+### Dateien herunterladen {#downloading-files}
+
+```python
+page = StealthyFetcher.fetch('https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/main_cover.png')
+
+with open(file='main_cover.png', mode='wb') as f:
+ f.write(page.body)
+```
+
+Das Attribut `body` eines `Response`-Objekts gibt immer `bytes` zurück.
+
+### Vorbereitung vor der Navigation {#pre-navigation-setup}
+Mit `page_setup` registrieren Sie Event-Listener, Routen oder Skripte, die vor der Navigation bereitstehen müssen. Die Funktion erhält das `page`-Objekt und läuft vor dem Aufruf von `page.goto()`.
+
+```python
+from patchright.sync_api import Page
+
+def capture_websockets(page: Page):
+ page.on("websocket", lambda ws: print(f"WebSocket opened: {ws.url}"))
+
+page = StealthyFetcher.fetch('https://example.com', page_setup=capture_websockets)
+```
+Asynchrone Variante:
+```python
+from patchright.async_api import Page
+
+async def capture_websockets(page: Page):
+ page.on("websocket", lambda ws: print(f"WebSocket opened: {ws.url}"))
+
+page = await StealthyFetcher.async_fetch('https://example.com', page_setup=capture_websockets)
+```
+
+Sie können dies mit `page_action` kombinieren. `page_setup` läuft vor der Navigation, `page_action` danach.
+
+### Cloudflare und Tarnungsoptionen {#cloudflare-and-stealth-options}
+
+```python
+
+page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare', solve_cloudflare=True)
+
+
+page = StealthyFetcher.fetch(
+ 'https://protected-site.com',
+ solve_cloudflare=True,
+ block_webrtc=True,
+ real_chrome=True,
+ hide_canvas=True,
+ google_search=True,
+ proxy='http://username:password@host:port', # It can also be a dictionary with only the keys 'server', 'username', and 'password'.
+)
+```
+
+Der Parameter `solve_cloudflare` aktiviert die automatische Erkennung und Lösung aller Arten von Cloudflare-Turnstile- und Interstitial-Prüfungen:
+
+- JavaScript-Prüfungen, die von Cloudflare gesteuert werden
+- Interaktive Prüfungen mit Bestätigungskästchen
+- Unsichtbare Prüfungen, die automatisch im Hintergrund laufen
+
+Auch eigene Seiten mit eingebettetem Captcha werden unterstützt.
+
+!!! notes "**Wichtige Hinweise:**"
+
+ 1. Bei Websites mit eigenen Umsetzungen müssen Sie manchmal `wait_selector` verwenden. So wartet Scrapling nach dem Lösen des Captchas auf den eigentlichen Seiteninhalt. Manche Websites sind echte Sonderfälle, während der Solver möglichst allgemein funktionieren soll.
+ 2. Für den Cloudflare-Solver sollte die maximale Wartezeit mindestens 60 Sekunden betragen, damit genug Zeit zum Lösen der Prüfung bleibt.
+ 3. Die Funktion arbeitet mit Proxys und den anderen Tarnungsoptionen zusammen.
+
+### Browser-Automatisierung {#browser-automation}
+Hier helfen Kenntnisse der [Page-API von Playwright](https://playwright.dev/python/docs/api/class-page). Die übergebene Funktion erhält das Page-Objekt von Playwright und führt die gewünschten Aktionen aus. Danach setzt der Fetcher seine Arbeit fort.
+
+Die Funktion läuft direkt nach dem Warten auf `network_idle`, falls aktiviert, und vor dem Warten auf `wait_selector`. Sie eignet sich also auch für andere Aufgaben als Automatisierung. Sie können die Seite nach Bedarf verändern.
+
+Im folgenden Beispiel nutze ich [Mausereignisse](https://playwright.dev/python/docs/api/class-mouse), um mit dem Mausrad zu scrollen und danach die Maus zu bewegen.
+```python
+from patchright.sync_api import Page
+
+def scroll_page(page: Page):
+ page.mouse.wheel(10, 0)
+ page.mouse.move(100, 400)
+ page.mouse.up()
+
+page = StealthyFetcher.fetch('https://example.com', page_action=scroll_page)
+```
+Bei der asynchronen Abrufmethode muss auch diese Funktion asynchron sein.
+```python
+from patchright.async_api import Page
+
+async def scroll_page(page: Page):
+ await page.mouse.wheel(10, 0)
+ await page.mouse.move(100, 400)
+ await page.mouse.up()
+
+page = await StealthyFetcher.async_fetch('https://example.com', page_action=scroll_page)
+```
+
+### Wartebedingungen {#wait-conditions}
+
+```python
+
+page = StealthyFetcher.fetch(
+ 'https://quotes.toscrape.com/js-delayed/',
+ wait_selector='.quote',
+ wait_selector_state='visible'
+)
+```
+Dies ist die letzte ausdrücklich gewählte Wartebedingung vor der Rückgabe der Antwort. Übergeben Sie einen CSS-Selektor an `wait_selector`. Der Fetcher wartet auf den in `wait_selector_state` angegebenen Zustand. Ohne Angabe gilt `attached`: Das Element muss im DOM vorhanden sein.
+
+Danach prüft der Fetcher bei aktiviertem `load_dom`, ob alle JavaScript-Dateien geladen und ausgeführt wurden, also der Zustand `domcontentloaded` erreicht ist. Falls nötig, wartet er weiter. Diese Option ist standardmäßig aktiviert. Wenn Sie `network_idle` aktiviert haben, wartet der Fetcher erneut auf `network_idle`.
+
+Diese Zustände sind möglich ([Quelle](https://playwright.dev/python/docs/api/class-page#page-wait-for-selector)):
+
+- `attached`: Wartet, bis ein Element im DOM vorhanden ist.
+- `detached`: Wartet, bis ein Element nicht mehr im DOM vorhanden ist.
+- `visible`: Wartet, bis das Element eine nicht leere Begrenzungsbox hat und nicht `visibility:hidden` verwendet. Ein Element ohne Inhalt oder mit `display:none` hat eine leere Begrenzungsbox und gilt nicht als sichtbar.
+- `hidden`: Wartet, bis das Element aus dem DOM entfernt ist, eine leere Begrenzungsbox hat oder `visibility:hidden` verwendet. Das ist das Gegenteil von `'visible'`.
+
+### Netzwerkverlauf {#network-history}
+
+Aktivieren Sie `record_requests` in einer Browser-Sitzung, um abgeschlossene Anfragen über Seitenaufrufe, Aktionen und Tabs hinweg zu prüfen. Der Verlauf umfasst alle Kontexte der Sitzung, auch temporäre Proxy-Kontexte. Antworten werden als Scrapling-`Response`-Objekte gespeichert. So finden Sie API-Aufrufe, HTTP-Fehler und Weiterleitungen, ohne Anfragen erneut zu senden. Gespeicherte Header und Antwortinhalte bleiben auch nach dem Schließen der Sitzung lesbar. Fehlgeschlagene und noch laufende Anfragen werden weggelassen. Abgeschlossene HTTP-Antworten mit Status 4xx oder 5xx sind enthalten.
+
+```python
+from scrapling.fetchers import StealthySession
+
+with StealthySession(record_requests=True, max_recorded_requests=1000) as session:
+ session.fetch('https://example.com', network_idle=True)
+
+for response in session.network.search(resource_type='document', limit=None):
+ print(response.meta['network_id'], response.url, response.status)
+ if note := response.meta.get('body_note'):
+ print(note)
+ else:
+ print(response.body)
+ print(response.css('title::text').get())
+
+session.network.clear()
+```
+
+Dieselbe API funktioniert mit `AsyncStealthySession`. Die Aufzeichnung ist standardmäßig deaktiviert. Setzen Sie beim Erstellen der Sitzung `record_requests=True` und bei Bedarf `max_recorded_requests`.
+
+- `session.network.search(url_pattern=None, method=None, resource_type=None, status=None, after_id=0, limit=100, include_static=True)` gibt gespeicherte `Response`-Objekte nach Netzwerk-ID sortiert zurück. Mit `limit=None` erhalten Sie alle noch gespeicherten Treffer. `url_pattern` ist eine Regex, die bei der Suche angewendet wird. Ein ungültiges Muster löst erst dann einen Fehler aus. `after_id` wählt Antworten mit einer höheren Netzwerk-ID aus. Mit `include_static=False` erhalten Sie XHR/fetch-Anfragen und HTTP-Fehler. Mit `True` erhalten Sie alle Ressourcentypen und gespeicherten Weiterleitungen.
+- `session.network.get(request_id)` gibt eine gespeicherte `Response` zurück, oder `None`, wenn sie nicht mehr gespeichert ist.
+- `session.network.clear()` entfernt den Verlauf. Anfrage-IDs steigen weiter an und werden nie erneut vergeben.
+
+Jede gespeicherte `Response` bietet direkt `.url`, `.method`, `.status`, `.headers`, `.request_headers`, `.body` als Bytes, `.json()` sowie CSS/XPath-Methoden. `.meta` enthält `network_id`, `resource_type` und `request_body`. Letzteres enthält Bytes oder `None`. Header können unvollständig sein, wenn das vollständige Auslesen fehlschlägt. Auch in asynchronen Sitzungen sind dies lokale Zugriffe. Verwenden Sie dafür weder await noch `.body()`. Wenn gespeicherter Inhalt nicht analysiert werden kann, bleiben seine Bytes erhalten. CSS/XPath-Methoden arbeiten dann mit einem leeren Dokument.
+
+Um API-Verkehr nach URL zu finden, verwenden Sie `session.network.search(url_pattern=r'https://api\.example\.com/.*', limit=None)`. Ergänzen Sie `resource_type='fetch'` oder `resource_type='xhr'`, wenn Sie einen bestimmten Anfragetyp brauchen.
+
+Die Aufzeichnung liest und speichert Antwortinhalte nur für unterstützte Textwerte von `Content-Type`: `text/*`, Typen mit `+json`/`+xml` einschließlich SVG, JSON, XML, JavaScript, GraphQL und URL-kodierte Formulardaten. Bei binären oder unbekannten Typen sowie Antworten ohne `Content-Type` bleiben die Metadaten erhalten, aber keine Inhaltsbytes. Der Browser lädt die Ressourcen weiterhin normal.
+
+Gespeicherte Antwortbytes stammen von Playwright und können von den ursprünglichen Bytes des Servers abweichen. Wenn sie gültiges UTF-8 enthalten, nutzt der aufgezeichnete Text UTF-8, wie bei Playwright. Sonst wird der angegebene Zeichensatz verwendet. Die Antwort-Header bleiben unverändert.
+
+Übersprungene, zu große oder nicht lesbare Antwortinhalte liefern `b''`. Der Grund steht in `response.meta.get('body_note')`. Bei Nicht-Text-Inhalten lautet er `Non-text body; not saved.`. Metadaten und verfügbare Header bleiben erhalten. Gespeicherter Text, auch leerer Text, hat keinen solchen Hinweis. HEAD-Antworten und die Statuscodes 204, 205 und 304 bleiben leer und haben ebenfalls keinen Hinweis.
+
+Die Methoden `search`, `get` und `clear` des Verlaufs sind lokale, synchrone Aufrufe, auch in asynchronen Sitzungen. Ein Eintrag erscheint erst, wenn seine Antwort umgewandelt und gespeichert wurde. Browser-Ereignisse werden verarbeitet, während Playwright aktiv ist. Asynchrone Aufzeichnungen brauchen außerdem eine laufende Event-Schleife. Das Lesen des Verlaufs wartet nicht auf laufende Aufzeichnungen.
+
+Auch das Schließen einer Sitzung wartet nicht auf Aufzeichnungen. Was bei einer Navigation oder beim Schließen des Browser-Kontexts noch läuft, kann fehlen. Bereits gespeicherte Antworten bleiben nach dem Schließen lesbar.
+
+Standardmäßig speichert der Verlauf bis zu 1.000 Anfragen. Für jeden Antwortinhalt gilt ein Limit von 1 MiB, für alle zusammen 20 MiB. Beim Erreichen der Speicherlimits werden ältere Einträge entfernt. Die Inhaltslimits sind fest und lassen sich nicht in den Sitzungseinstellungen ändern. Sie betreffen gespeicherte Einträge und Antwortbytes, nicht den gesamten Browserspeicher, gleichzeitige Aufzeichnungen, vorübergehendes vollständiges Auslesen, analysiertes HTML oder Anfrageinhalte.
+
+#### Umstieg auf v5 {#migrating-in-v5}
+
+`capture_xhr` und `response.captured_xhr` wurden in v5 entfernt. Verwenden Sie eine eigene Browser-Sitzung mit `record_requests=True` und lesen Sie dann `session.network.search(url_pattern=..., limit=None)`. Dies ersetzt auch die API-Aufzeichnung über einzelne Fetcher-Aufrufe. Behalten Sie deshalb die Sitzungsinstanz. Filter gelten für den gespeicherten Verlauf der gesamten Sitzung, nicht für die Aufzeichnung oder einen einzelnen Abruf. Es werden nur unterstützte Textinhalte gespeichert. `search()` liefert standardmäßig höchstens 100 Treffer. Mit `limit=None` erhalten Sie alle noch gespeicherten Treffer, ohne die Speicherlimits des Verlaufs zu ändern.
+
+### Browser-Header und regionale Einstellungen {#browser-headers-and-locale}
+
+```python
+page = StealthyFetcher.fetch(
+ 'https://example.com',
+ google_search=True,
+ useragent='Mozilla/5.0...',
+ locale='en-US',
+)
+```
+
+### Allgemeines Beispiel {#general-example}
+```python
+from scrapling.fetchers import StealthyFetcher
+
+def scrape_dynamic_content():
+
+ page = StealthyFetcher.fetch(
+ 'https://example.com/dynamic',
+ network_idle=True,
+ wait_selector='.content'
+ )
+
+
+ content = page.css('.content')
+
+ return {
+ 'title': content.css('h1::text').get(),
+ 'items': [
+ item.text for item in content.css('.item')
+ ]
+ }
+```
+
+### Proxy-Wechsel {#proxy-rotation}
+
+```python
+from scrapling.fetchers import StealthySession, ProxyRotator
+
+
+rotator = ProxyRotator([
+ "http://proxy1:8080",
+ "http://proxy2:8080",
+ "http://proxy3:8080",
+])
+
+
+with StealthySession(proxy_rotator=rotator, headless=True) as session:
+ page1 = session.fetch('https://example1.com')
+ page2 = session.fetch('https://example2.com')
+
+
+ page3 = session.fetch('https://example3.com', proxy='http://specific-proxy:8080')
+```
+
+!!! warning
+
+ Alle Browser-Fetcher und ihre Sitzungen nutzen standardmäßig einen dauerhaften Browser-Kontext mit einem Tab-Pool. Browser können jedoch keinen eigenen Proxy pro Tab setzen. Mit `ProxyRotator` öffnet der Fetcher deshalb für jeden Proxy einen eigenen Kontext mit einem Tab. Nach Abschluss der Aufgabe werden sowohl der Tab als auch sein Kontext geschlossen.
+
+## Wann eignet sich dieser Fetcher? {#when-to-use}
+
+Verwenden Sie StealthyFetcher, wenn Sie:
+
+- Schutzmaßnahmen gegen Bots umgehen müssen.
+- einen zuverlässigen Browser-Fingerprint brauchen.
+- vollständige JavaScript-Unterstützung brauchen.
+- automatische Tarnungsfunktionen nutzen möchten.
+- Browser-Automatisierung brauchen.
+- mit Cloudflare-Schutz arbeiten.
diff --git a/docs/locales/de/index.md b/docs/locales/de/index.md
new file mode 100644
index 0000000..a070a31
--- /dev/null
+++ b/docs/locales/de/index.md
@@ -0,0 +1,243 @@
+---
+title: "Scrapling: Web-Scraping-Framework für Python"
+description: "Scrapling: Daten aus dem modernen Web einfach extrahieren."
+---
+
+<style>
+.md-typeset h1 {
+ display: none;
+}
+[data-md-color-scheme="default"] .only-dark { display: none; }
+[data-md-color-scheme="slate"] .only-light { display: none; }
+</style>
+
+<br/>
+<div align="center">
+ <a href="index.html" alt="Titelbild">
+ <img alt="Scrapling" src="assets/cover_light.svg" class="only-light">
+ <img alt="Scrapling" src="assets/cover_dark.svg" class="only-dark">
+ </a>
+</div>
+
+<h2 align="center"><i>Daten aus dem modernen Web einfach extrahieren</i></h2><br>
+
+Scrapling ist ein Web-Scraping-Framework für Python. Es vereint schnelle HTTP-Anfragen, Stealth-Browser, die Auswertung von Seiten und paralleles Crawling in einer Bibliothek.
+
+Extrahieren Sie Daten aus statischen Seiten, führen Sie JavaScript aus, bedienen Sie Websites und greifen Sie auf deren APIs zu. Erstellen Sie Crawler mit wiederverwendbaren Sitzungen, Proxy-Rotation, automatischen Wiederholungsversuchen, Pause und Fortsetzung sowie integriertem Datenexport.
+
+Nutzen Sie Scrapling in Python, im Terminal oder mit Ihrem KI-Agenten über den MCP-Server und den Agent Skill. Es deckt den ganzen Ablauf ab: von wenigen Feldern bis zum Speichern einer ganzen Website als saubere Markdown-Dateien.
+
+## Was Sie mit Scrapling machen können {#what-you-can-do-with-scrapling}
+
+- **[Seiten abrufen und bedienen](fetching/choosing.md)**: Schnelle HTTP-Anfragen, Stealth-Browser, JavaScript-Ausführung, Umgang mit Cloudflare Turnstile und Interstitial, dauerhafte Sitzungen und Aufzeichnung von API-Antworten im Hintergrund.
+- **[Seiten auswerten und Daten extrahieren](parsing/selection.md)**: Suche mit CSS, XPath, Text und regulären Ausdrücken, Wiederfinden von Elementen nach Änderungen der Seite, Suche nach ähnlichen Elementen und saubere Markdown-Ausgabe.
+- **[Crawlen und exportieren](spiders/getting-started.md)**: Parallele Spider, Proxy-Rotation, Wiederholungsversuche, AutoThrottle, Pause und Fortsetzung, Streaming, fertige Vorlagen und Export nach JSON, JSONL, CSV und XML.
+- **[Daten mit KI oder im Terminal extrahieren](ai/mcp-server.md)**: Ein MCP-Server zum Browsen und Extrahieren von Daten mit KI-Agenten, ein Agent Skill, CLI-Befehle und eine interaktive Shell.
+
+Beginnen Sie mit einer einzelnen Seite:
+
+```python
+from scrapling.fetchers import Fetcher
+
+page = Fetcher.get('https://quotes.toscrape.com/')
+quotes = page.css('.quote .text::text').getall()
+print(quotes)
+```
+
+Oder extrahieren Sie mehr Daten mit einem Spider:
+
+```python
+from scrapling.spiders import Spider, Response
+
+class QuotesSpider(Spider):
+ name = "quotes"
+ start_urls = ["https://quotes.toscrape.com/"]
+
+ async def parse(self, response: Response):
+ for quote in response.css('.quote'):
+ yield {
+ "text": quote.css('.text::text').get(),
+ "author": quote.css('.author::text').get(),
+ }
+
+result = QuotesSpider().start()
+print(len(result.items))
+result.items.to_json("quotes.json")
+```
+
+Dieses Beispiel gibt `10` aus und speichert die Zitate und ihre Autoren in `quotes.json`.
+
+## Hauptsponsoren {#top-sponsors}
+
+--8<-- "sponsors.html"
+
+<i><sub>Möchten Sie hier werben? Klicken Sie [hier](https://github.com/sponsors/D4Vinci), wählen Sie ein Angebot und nutzen Sie die Vorteile.</sub></i>
+
+## Wichtige Funktionen {#key-features}
+
+### Spider: ein vollständiges Crawling-Framework {#spiders-a-full-crawling-framework}
+- 🕷️ **Spider-API ähnlich wie Scrapy**: Definieren Sie Spider mit `start_urls`, asynchronen `parse`-Callbacks sowie `Request`- und `Response`-Objekten.
+- ⚡ **Paralleles Crawling**: Legen Sie die Anzahl gleichzeitiger Anfragen, die Grenzen pro Domain und die Wartezeit zwischen Downloads fest.
+- 🔄 **Mehrere Sitzungen**: Nutzen Sie HTTP-Anfragen und Stealth-Browser ohne grafische Oberfläche im selben Spider. Leiten Sie Anfragen über die ID an unterschiedliche Sitzungen weiter.
+- 💾 **Pause und Fortsetzung**: Speichern Sie ausstehende Anfragen und besuchte URLs mit `crawldir`. Drücken Sie Strg+C, um sicher anzuhalten, und starten Sie mit demselben Ordner erneut.
+- 📡 **Ergebnisse als Stream**: Empfangen Sie Elemente direkt nach dem Extrahieren mit `async for item in spider.stream()`, zusammen mit Statistiken in Echtzeit. Das eignet sich für Oberflächen, Datenverarbeitung und lange Crawls.
+- 🛡️ **Blockierte Anfragen erkennen**: Erkennen und wiederholen Sie blockierte Anfragen automatisch. Sie können das Verhalten anpassen.
+- 🚦 **AutoThrottle**: Der Spider passt die Wartezeit pro Domain an die Antwortgeschwindigkeit der Website an. Blockiert oder begrenzt die Website Anfragen, verdoppelt er die Wartezeit oder hält die von `Retry-After` angegebene Zeit ein. Danach beschleunigt er wieder.
+- 🤖 **robots.txt beachten**: Aktivieren Sie `robots_txt_obey`, um die Vorgaben `Disallow`, `Crawl-delay` und `Request-rate` zu beachten. Die Angaben werden pro Domain zwischengespeichert.
+- 🧪 **Entwicklungsmodus**: Speichern Sie Antworten beim ersten Lauf auf der Festplatte und nutzen Sie sie danach erneut. So können Sie `parse()` anpassen, ohne neue Anfragen an die Server zu senden.
+- 🧩 **Fertige Spider-Vorlagen**: Nutzen Sie `CrawlSpider`, um Links nach Regeln zu folgen, `SitemapSpider` für Crawls über Sitemaps oder robots.txt, `XMLFeedSpider` und `CSVFeedSpider` zum Lesen von XML-, RSS- und CSV-Feeds sowie `ShopifySpider` zum Sammeln von Produkten aus öffentlichen Shopify-Shops, mit einem Element pro Variante.
+- 🔗 **Links extrahieren**: `LinkExtractor` erlaubt oder verwirft Links anhand von Mustern, filtert Domains und Dateiendungen, begrenzt die Suche mit CSS oder XPath und vereinheitlicht URLs. Nutzen Sie ihn mit den Vorlagen oder einzeln.
+- 📦 **Integrierter Export**: Exportieren Sie Ergebnisse mit Hooks und Ihrer eigenen Datenverarbeitung oder mit den integrierten Formaten JSON, JSONL, CSV und XML: `result.items.to_json()`, `to_jsonl()`, `to_csv()` und `to_xml()`.
+
+### Seiten mit Sitzungen abrufen {#advanced-websites-fetching-with-session-support}
+- **HTTP-Anfragen**: Senden Sie schnelle und unauffällige HTTP-Anfragen mit `Fetcher`. Sie können TLS-Fingerprints und Header eines Browsers nachbilden und HTTP/3 nutzen.
+- **Dynamisches Laden**: Rufen Sie dynamische Websites mit vollständiger Browserautomatisierung über `StealthyFetcher` ab. Er unterstützt das Chromium von Playwright und Google Chrome.
+- **Antibot-Systeme umgehen**: `StealthyFetcher` verbirgt die Automatisierung und bildet Browser-Fingerprints nach. Er kann verschiedene Arten von Cloudflare Turnstile und Interstitial automatisch lösen.
+- **Sitzungen verwalten**: `FetcherSession` und `StealthySession` behalten Cookies und den Zustand zwischen Anfragen bei.
+- **Proxy-Rotation**: `ProxyRotator` wechselt Proxys zyklisch oder nach eigenen Regeln in allen Sitzungstypen. Sie können auch einen Proxy für eine einzelne Anfrage wählen.
+- **Domains und Werbung blockieren**: Blockieren Sie Anfragen an bestimmte Domains und deren Subdomains, oder aktivieren Sie den Werbeblocker der Browser-Fetcher. Er umfasst etwa 3.500 bekannte Werbe- und Tracking-Domains.
+- **DNS-Lecks verhindern**: Aktivieren Sie DNS-over-HTTPS, um DNS-Anfragen über den DoH-Dienst von Cloudflare zu senden und Lecks bei der Nutzung von Proxys zu verhindern.
+- **Entfernte Browser**: Verbinden Sie sich über CDP und `cdp_url` mit einem laufenden Browser, auf Ihrem Computer, einem anderen Server oder bei einem Browserdienst. Mit `executable_path` können Sie auch Ihre eigene Chromium-Version für jeden Browser-Fetcher verwenden.
+- **API-Antworten im Hintergrund aufzeichnen**: Aktivieren Sie `record_requests=True` in einer Browsersitzung und suchen Sie gespeicherte Antworten mit `session.network.search(limit=None)`. Lesen Sie API-Daten und HTTP-Fehler aus mehreren Seitenaufrufen, ohne die Anfragen zu wiederholen. Der Verlauf ist in seiner Größe begrenzt und speichert den Inhalt von Textantworten.
+- **Asynchroner Betrieb**: Alle Fetcher lassen sich asynchron nutzen. Dafür gibt es eigene Sitzungsklassen.
+
+### Seiten auswerten und Daten extrahieren {#parsing-and-data-extraction}
+- 🔄 **Elemente wiederfinden**: Finden Sie Elemente nach Änderungen der Website mit Algorithmen zur Ähnlichkeitssuche wieder.
+- 🎯 **Flexible Auswahl**: Nutzen Sie CSS, XPath, Filter, Text, reguläre Ausdrücke und mehr.
+- 🔍 **Ähnliche Elemente**: Finden Sie automatisch Elemente, die den bereits gefundenen ähneln.
+
+### KI-Funktionen {#ai-features}
+- 🤖 **MCP-Server**: Ermöglicht Assistenten und KI-Agenten wie Claude und Cursor, Daten mit Scrapling zu extrahieren. Dazu dienen HTTP-Anfragen, Browseraktionen, Screenshots, ein gespeicherter Anmeldezustand und API-Antworten im Hintergrund. Er nutzt unseren Stealth-Browser und Werkzeuge, mit denen geeignete Modelle CAPTCHAs lösen können, zusätzlich zum Cloudflare-Löser. Er verringert den an das Modell gesendeten Inhalt, blockiert Werbung und schützt vor Prompt Injection. Entfernte Browser über CDP und HTTP-Verbindungen mit Authentifizierungsoptionen sind ebenfalls möglich. ([Demovideo](https://www.youtube.com/watch?v=qyFk3ZNwOxE))
+- 🧠 **Agent Skill**: Ein [Agent Skill](ai/agent-skill.md) zum Installieren, der Coding-Agenten die Bibliothek erklärt. So schreiben sie Code, der zur aktuellen API passt.
+- 📚 **Markdown für RAG**: Wandeln Sie eine Seite mit einer Zeile (`page.markdown()`) in sauberes Markdown für Sprachmodelle um, oder speichern Sie mit der Vorlage `ContentSpider` eine ganze Website als Markdown-Dateien. Dafür ist kein Sprachmodell nötig. ([Dokumentation](ai/building-rag-systems.md))
+
+### Schnell und im Alltag erprobt {#high-performance-battle-tested-architecture}
+- 🚀 **Hohe Geschwindigkeit**: Optimierte Leistung, die die meisten Web-Scraping-Bibliotheken für Python übertrifft.
+- 🔋 **Geringer Speicherbedarf**: Optimierte Datenstrukturen und Laden bei Bedarf.
+- ⚡ **Schnelle JSON-Ausgabe**: 10-mal schneller als die Standardbibliothek.
+- 🏗️ **In der Praxis getestet**: Tests decken 92 % von Scrapling ab, und der gesamte Code hat Typannotationen. Hunderte Menschen haben es im letzten Jahr täglich zur Datenextraktion verwendet.
+
+### Werkzeuge für Entwicklung und Datenextraktion {#developerweb-scraper-friendly-experience}
+- 🎯 **Interaktive Shell**: Eine optionale IPython-Shell mit Scrapling, Kurzbefehlen und Werkzeugen für die schnelle Entwicklung von Skripten. Wandeln Sie curl-Anfragen in Scrapling-Anfragen um und zeigen Sie Ergebnisse im Browser an.
+- 🚀 **Nutzung im Terminal**: Extrahieren Sie die Daten einer URL, ohne Code zu schreiben.
+- 🛠️ **Navigation im DOM**: Greifen Sie auf Eltern-, Geschwister- und Kindelemente zu.
+- 🧬 **Textverarbeitung**: Reguläre Ausdrücke, Textbereinigung und optimierte Arbeit mit Zeichenketten.
+- 📝 **Selektoren erzeugen**: Erstellen Sie zuverlässige CSS- und XPath-Selektoren für jedes Element.
+- 🔌 **Vertraute API**: Ähnlich wie Scrapy und BeautifulSoup, mit denselben Pseudoelementen wie Scrapy und Parsel.
+- 🤝 **Direkte Integration mit Scrapy**: Ergänzen Sie einen Callback um den Dekorator `scrapling_response`, um die bereits abgerufenen Antworten mit dem Scrapling-Parser auszuwerten. Sie müssen Ihr Programm nicht neu schreiben.
+- 📘 **Vollständige Typannotationen**: Sie helfen dem Editor, Code zu prüfen und zu vervollständigen. Der gesamte Code wird bei jeder Änderung automatisch mit **PyRight** und **MyPy** geprüft.
+- 🔋 **Fertiges Docker-Image**: Bei jeder Version wird automatisch ein Docker-Image mit allen Browsern erstellt und veröffentlicht.
+
+
+## Sterne auf GitHub {#star-history}
+Die Zahl der GitHub-Sterne von Scrapling wächst seit seiner Veröffentlichung, wie die Grafik zeigt.
+
+<div id="chartContainer">
+ <a href="https://github.com/D4Vinci/Scrapling">
+ <img id="chartImage" alt="Verlauf der GitHub-Sterne" loading="lazy" src="https://api.star-history.com/svg?repos=D4Vinci/Scrapling&type=Date" height="400"/>
+ </a>
+</div>
+
+<script>
+const observer = new MutationObserver((mutations) => {
+ mutations.forEach((mutation) => {
+ if (mutation.attributeName === 'data-md-color-media') {
+ const colorMedia = document.body.getAttribute('data-md-color-media');
+ const isDarkScheme = document.body.getAttribute('data-md-color-scheme') === 'slate';
+ const chartImg = document.querySelector('#chartImage');
+ const baseUrl = 'https://api.star-history.com/svg?repos=D4Vinci/Scrapling&type=Date';
+
+ if (colorMedia === '(prefers-color-scheme)' ? isDarkScheme : colorMedia.includes('dark')) {
+ chartImg.src = `${baseUrl}&theme=dark`;
+ } else {
+ chartImg.src = baseUrl;
+ }
+ }
+ });
+});
+
+observer.observe(document.body, {
+ attributes: true,
+ attributeFilter: ['data-md-color-media', 'data-md-color-scheme']
+});
+</script>
+
+
+## Installation {#installation}
+Scrapling benötigt Python 3.10 oder neuer:
+
+```bash
+pip install scrapling
+```
+
+!!! warning "Achtung"
+
+ Dieser Befehl installiert nur den Parser und seine Abhängigkeiten, ohne Fetcher oder Werkzeuge für die Kommandozeile. Wenn Sie nur das installieren, führt ein Import aus `scrapling.fetchers` oder `scrapling.spiders`, wie in den Beispielen oben, zu `ModuleNotFoundError`. Für Fetcher oder Spider müssen Sie zuerst die Fetcher-Abhängigkeiten wie unten gezeigt installieren.
+
+### Optionale Abhängigkeiten {#optional-dependencies}
+
+1. Für Fetcher, deren Klassen oder die folgenden Zusatzfunktionen installieren Sie die Abhängigkeiten der Fetcher und Browser:
+ ```bash
+ pip install "scrapling[fetchers]"
+
+ scrapling install # normal install
+ scrapling install --force # force reinstall
+ ```
+
+ Dadurch werden alle Browser, ihre Systemabhängigkeiten und die Werkzeuge zum Ändern der Browser-Fingerprints heruntergeladen.
+
+ Sie können sie auch aus Python installieren, statt einen Befehl auszuführen:
+ ```python
+ from scrapling.cli import install
+
+ install([], standalone_mode=False) # normal install
+ install(["--force"], standalone_mode=False) # force reinstall
+ ```
+
+2. Zusatzfunktionen:
+
+
+ - Den MCP-Server installieren:
+ ```bash
+ pip install "scrapling[ai]"
+ ```
+ - Die Abhängigkeiten zum [Aufbau von RAG-Systemen](ai/building-rag-systems.md) installieren:
+ ```bash
+ pip install "scrapling[rag]"
+ ```
+ - Die interaktive Shell und den Befehl `extract` installieren:
+ ```bash
+ pip install "scrapling[shell]"
+ ```
+ - Alles installieren:
+ ```bash
+ pip install "scrapling[all]"
+ ```
+ Führen Sie `scrapling install` aus, wenn Sie Browser-Fetcher nutzen möchten. HTTP-Anfragen benötigen keinen Browser.
+
+### Docker {#docker}
+Sie können auch ein Docker-Image mit allen Extras und Browsern von DockerHub herunterladen:
+```bash
+docker pull pyd4vinci/scrapling
+```
+Oder aus der GitHub-Registry herunterladen:
+```bash
+docker pull ghcr.io/d4vinci/scrapling:latest
+```
+Das Image wird aus dem Hauptbranch des Repositorys erstellt und von GitHub Actions automatisch veröffentlicht.
+
+## Aufbau der Dokumentation {#how-the-documentation-is-organized}
+Die Scrapling-Dokumentation ist umfangreich. Deshalb folgen wir dem [Diátaxis-Modell für Dokumentation](https://diataxis.fr/).
+
+## Unterstützung {#support}
+
+Wenn Ihnen Scrapling gefällt und Sie die Entwicklung unterstützen möchten:
+
+- ⭐ Geben Sie dem [GitHub-Repository](https://github.com/D4Vinci/Scrapling) einen Stern.
+- 🚀 Folgen Sie uns auf [Twitter](https://x.com/Scrapling_dev) und treten Sie dem [Discord-Server](https://discord.gg/EMgGbDceNQ) bei.
+- 💝 Sie können [das Projekt sponsern oder mir einen Kaffee spendieren](donate.md). :wink:
+- 🐛 Melden Sie Fehler und schlagen Sie Funktionen auf [GitHub Issues](https://github.com/D4Vinci/Scrapling/issues) vor.
+
+## Lizenz {#license}
+
+Dieses Projekt nutzt die BSD-3-Lizenz. Weitere Angaben stehen in der Datei [LICENSE](https://github.com/D4Vinci/Scrapling/blob/main/LICENSE).
diff --git a/docs/locales/de/integrations/scrapy.md b/docs/locales/de/integrations/scrapy.md
new file mode 100644
index 0000000..841832e
--- /dev/null
+++ b/docs/locales/de/integrations/scrapy.md
@@ -0,0 +1,64 @@
+---
+title: "Scrapling-Parsing in einem Scrapy-Spider verwenden"
+description: "Wandeln Sie Scrapy-Antworten in Scrapling-Antworten um oder versehen Sie einen Callback mit einem Dekorator. Behalten Sie Ihren Scrapy-Crawler und nutzen Sie Scraplings Selektoren und adaptives Parsing."
+---
+
+# Scrapling in Scrapy einbinden {#integrating-scrapling-into-scrapy}
+
+Sie müssen ein bestehendes Scrapy-Projekt nicht neu schreiben, um Scraplings Parsing-API zu nutzen. Die Integration wandelt Scrapy-Antworten direkt in Ihren Spider-Callbacks in [Response](../fetching/choosing.md#response-object)-Objekte von Scrapling um. Scrapy übernimmt weiter das Crawling, während Scrapling den Inhalt parst.
+
+!!! note "Installation"
+
+ Diese Integration funktioniert mit der Standardinstallation von Scrapling (`pip install scrapling`). Extras sind nicht nötig. Nur Scrapy muss installiert sein, was bei einem Scrapy-Projekt bereits der Fall ist.
+
+## Verwendung {#usage}
+
+Fügen Sie einem Spider-Callback den Dekorator `scrapling_response` hinzu. Das Argument `response`, das er erhält, wird dann zu einem Scrapling-`Response`:
+
+```python
+import scrapy
+from scrapling.integrations.scrapy import scrapling_response
+
+
+class QuotesSpider(scrapy.Spider):
+ name = "quotes"
+ start_urls = ["https://quotes.toscrape.com"]
+
+ @scrapling_response
+ def parse(self, response): # `response` is now a Scrapling Response
+ first_quote = response.find_by_text("The world as we have created it", partial=True)
+ for quote in [first_quote, *first_quote.find_similar()]:
+ card = quote.parent
+ yield {
+ "text": quote.get_all_text(strip=True),
+ "author": card.find("small", class_="author").text,
+ "tags": [tag.text for tag in card.find_all("a", class_="tag")],
+ }
+ next_page = response.css("li.next a::attr(href)").get()
+ if next_page:
+ yield scrapy.Request(response.urljoin(next_page), callback=self.parse)
+```
+
+Der Dekorator unterstützt alle Callback-Arten von Scrapy: normale Funktionen, Generatoren, Coroutinen und asynchrone Generatoren. Er behält die Art, den Namen und den Docstring des Callbacks bei. Scrapy kann den Callback also weiterhin untersuchen und seine Contracts prüfen.
+
+Sie können dem Dekorator auch eine [Selector](../parsing/main_classes.md#selector)-Konfiguration übergeben. Sie wird an das erzeugte `Response` weitergegeben:
+
+```python
+ @scrapling_response(adaptive=True, keep_comments=True)
+ def parse_product(self, response):
+ ...
+```
+
+Wenn Sie eine Scrapy-Antwort außerhalb eines Callbacks haben, zum Beispiel in einer Middleware oder Pipeline, verwenden Sie den Konverter direkt:
+
+```python
+from scrapling.integrations.scrapy import convert_response
+
+scrapling_response = convert_response(scrapy_response, keep_comments=False)
+```
+
+## Hinweise {#notes}
+
+- Geben Sie für weitere Seiten wie im Beispiel oben `scrapy.Request(response.urljoin(href))` mit yield aus. Scraplings Methode `Response.follow()` erstellt Anfragen für das [Spider-System von Scrapling](../spiders/getting-started.md), die Scrapy nicht versteht.
+- Das Wörterbuch `meta` der Antwort wird flach kopiert. Darin gespeicherte Objekte anderer Middlewares bleiben also erreichbar. Mit `scrapy-playwright` ist die Seite zum Beispiel weiterhin unter `response.meta["playwright_page"]` verfügbar.
+- Cookies werden aus den rohen `Set-Cookie`-Headern gelesen und in das Wörterbuch `cookies` der Antwort eingefügt.
diff --git a/docs/locales/de/overview.md b/docs/locales/de/overview.md
new file mode 100644
index 0000000..907d569
--- /dev/null
+++ b/docs/locales/de/overview.md
@@ -0,0 +1,341 @@
+---
+title: "Scrapling-Anleitung: Seiten auswerten, HTTP und Stealth-Browser"
+description: "Lernen Sie Scrapling mit Beispielen für CSS, XPath, Textsuche, HTTP-Anfragen und Stealth-Browser kennen."
+---
+
+# Erste Schritte mit Scrapling {#get-started-with-scrapling}
+
+## Wählen Sie Ihren Einstieg {#pick-your-path}
+
+Sie wissen noch nicht, wo Sie anfangen sollen? Wählen Sie die passende Aufgabe:
+
+| Ich möchte … | Hier beginnen |
+|:---|:---|
+| **HTML auswerten**, das ich bereits habe | [Elemente auswählen](parsing/selection.md): CSS, XPath und Textsuche |
+| **Schnell eine Seite extrahieren** und eine Idee testen | Wählen und testen Sie einen [Fetcher](fetching/choosing.md), oder öffnen Sie die [interaktive Shell](cli/interactive-shell.md) |
+| **Einen Crawler erstellen**, der mehr Seiten verarbeiten kann | [Spider](spiders/getting-started.md): paralleles Crawling mit mehreren Sitzungen, Pause und Fortsetzung |
+| **Daten ohne eigenen Code extrahieren** | Nutzen Sie die [Extraktionsbefehle](cli/extract-commands.md), oder verbinden Sie den [MCP-Server](ai/mcp-server.md) mit Ihrem KI-Werkzeug |
+| **Von einer anderen Bibliothek wechseln** | [Von BeautifulSoup](tutorials/migrating_from_beautifulsoup.md) oder [Vergleich mit Scrapy](spiders/architecture.md#comparison-with-scrapy) |
+
+---
+
+Zuerst werten wir Seiten aus. Danach rufen wir Seiten mit Browsern ab, senden Anfragen und werten die Antworten aus.
+
+Für die Beispiele auf dieser Seite verwenden wir dieses von ChatGPT erstellte HTML-Dokument:
+```python
+html_doc = """<html>
+ <head>
+ <title>Complex Web Page</title>
+ <style>
+ .hidden { display: none; }
+ </style>
+ </head>
+ <body>
+ <header>
+ <nav>
+ <ul>
+ <li> <a href="#home">Home</a> </li>
+ <li> <a href="#about">About</a> </li>
+ <li> <a href="#contact">Contact</a> </li>
+ </ul>
+ </nav>
+ </header>
+ <main>
+ <section id="products" schema='{"jsonable": "data"}'>
+ <h2>Products</h2>
+ <div class="product-list">
+ <article class="product" data-id="1">
+ <h3>Product 1</h3>
+ <p class="description">This is product 1</p>
+ <span class="price">$10.99</span>
+ <div class="hidden stock">In stock: 5</div>
+ </article>
+
+ <article class="product" data-id="2">
+ <h3>Product 2</h3>
+ <p class="description">This is product 2</p>
+ <span class="price">$20.99</span>
+ <div class="hidden stock">In stock: 3</div>
+ </article>
+
+ <article class="product" data-id="3">
+ <h3>Product 3</h3>
+ <p class="description">This is product 3</p>
+ <span class="price">$15.99</span>
+ <div class="hidden stock">Out of stock</div>
+ </article>
+ </div>
+ </section>
+
+ <section id="reviews">
+ <h2>Customer Reviews</h2>
+ <div class="review-list">
+ <div class="review" data-rating="5">
+ <p class="review-text">Great product!</p>
+ <span class="reviewer">John Doe</span>
+ </div>
+ <div class="review" data-rating="4">
+ <p class="review-text">Good value for money.</p>
+ <span class="reviewer">Jane Smith</span>
+ </div>
+ </div>
+ </section>
+ </main>
+ <script id="page-data" type="application/json">
+ {
+ "lastUpdated": "2024-09-22T10:30:00Z",
+ "totalProducts": 3
+ }
+ </script>
+ </body>
+</html>"""
+```
+Laden Sie zuerst das HTML von oben:
+```python
+import re
+from scrapling.parser import Selector
+page = Selector(html_doc)
+page # <data='<html><head><title>Complex Web Page</tit...'>
+```
+Rufen Sie den gesamten Text der Seite ab, auch den Text verschachtelter Elemente:
+```python
+page.get_all_text(ignore_tags=('script', 'style'))
+# 'Complex Web Page\nHome\nAbout\nContact\nProducts\nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock\nCustomer Reviews\nGreat product!\nJohn Doe\nGood value for money.\nJane Smith'
+```
+
+## Elemente suchen {#finding-elements}
+Sie können verschiedene Methoden kombinieren, um die benötigten Elemente zu finden.
+
+Suchen Sie das erste HTML-Element `section`:
+```python
+section_element = page.find('section')
+# <data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>
+```
+Suchen Sie alle `section`-Elemente:
+```python
+section_elements = page.find_all('section')
+# [<data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>, <data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>]
+```
+Suchen Sie alle `section`-Elemente, deren Attribut `id` den Wert `products` hat:
+```python
+section_elements = page.find_all('section', {'id':"products"})
+# Same as
+section_elements = page.find_all('section', id="products")
+# [<data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>]
+```
+Suchen Sie alle `section`-Elemente, deren Attribut `id` den Text `product` enthält:
+```python
+section_elements = page.find_all('section', {'id*':"product"})
+```
+Suchen Sie `h3`-Elemente, deren Text zum regulären Ausdruck `Product \d` passt:
+```python
+page.find_all('h3', re.compile(r'Product \d'))
+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]
+```
+Suchen Sie `h3`- und `h2`-Elemente, deren Text zum regulären Ausdruck `Product` passt:
+```python
+page.find_all(['h3', 'h2'], re.compile(r'Product'))
+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>, <data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>]
+```
+Suchen Sie Elemente, deren Text genau `Products` ist. Leerraum wird dabei nicht berücksichtigt:
+```python
+page.find_by_text('Products', first_match=False)
+# [<data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>]
+```
+Oder suchen Sie Elemente, deren Text zum regulären Ausdruck `Product \d` passt:
+```python
+page.find_by_regex(r'Product \d', first_match=False)
+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]
+```
+Suchen Sie Elemente, die dem ausgewählten Element ähneln:
+```python
+target_element = page.find_by_regex(r'Product \d', first_match=True)
+# <data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>
+target_element.find_similar()
+# [<data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]
+```
+Suchen Sie das erste Element, das zu einem CSS-Selektor passt:
+```python
+page.css('.product-list [data-id="1"]')[0]
+# <data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>
+```
+Suchen Sie alle Elemente, die zu einem CSS-Selektor passen:
+```python
+page.css('.product-list article')
+# [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+```
+Suchen Sie das erste Element, das zu einem XPath-Selektor passt:
+```python
+page.xpath("//*[@id='products']/div/article")[0]
+# <data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>
+```
+Suchen Sie alle Elemente, die zu einem XPath-Selektor passen:
+```python
+page.xpath("//*[@id='products']/div/article")
+# [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+```
+
+Das sind die Grundfunktionen. Weitere Optionen dieser Auswahlmethoden folgen später.
+## Daten der Elemente lesen {#accessing-elements-data}
+So lesen Sie die Daten:
+```pycon
+>>> section_element.tag
+'section'
+>>> print(section_element.attrib)
+{'id': 'products', 'schema': '{"jsonable": "data"}'}
+>>> section_element.attrib['schema'].json() # If an attribute value can be converted to json, then use `.json()` to convert it
+{'jsonable': 'data'}
+>>> section_element.text # Direct text content
+''
+>>> section_element.get_all_text() # All text content recursively
+'Products\nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock'
+>>> section_element.html_content # The HTML content of the element
+'<section id="products" schema=\'{"jsonable": "data"}\'><h2>Products</h2>\n <div class="product-list">\n <article class="product" data-id="1"><h3>Product 1</h3>\n <p class="description">This is product 1</p>\n <span class="price">$10.99</span>\n <div class="hidden stock">In stock: 5</div>\n </article><article class="product" data-id="2"><h3>Product 2</h3>\n <p class="description">This is product 2</p>\n <span class="price">$20.99</span>\n <div class="hidden stock">In stock: 3</div>\n </article><article class="product" data-id="3"><h3>Product 3</h3>\n <p class="description">This is product 3</p>\n <span class="price">$15.99</span>\n <div class="hidden stock">Out of stock</div>\n </article></div>\n </section>'
+>>> print(section_element.prettify()) # The prettified version
+'''
+<section id="products" schema='{"jsonable": "data"}'><h2>Products</h2>
+ <div class="product-list">
+ <article class="product" data-id="1"><h3>Product 1</h3>
+ <p class="description">This is product 1</p>
+ <span class="price">$10.99</span>
+ <div class="hidden stock">In stock: 5</div>
+ </article><article class="product" data-id="2"><h3>Product 2</h3>
+ <p class="description">This is product 2</p>
+ <span class="price">$20.99</span>
+ <div class="hidden stock">In stock: 3</div>
+ </article><article class="product" data-id="3"><h3>Product 3</h3>
+ <p class="description">This is product 3</p>
+ <span class="price">$15.99</span>
+ <div class="hidden stock">Out of stock</div>
+ </article>
+ </div>
+</section>
+'''
+>>> section_element.path # All the ancestors in the DOM tree of this element
+[<data='<main><section id="products" schema='{"j...' parent='<body> <header><nav><ul><li> <a href="#h...'>,
+ <data='<body> <header><nav><ul><li> <a href="#h...' parent='<html><head><title>Complex Web Page</tit...'>,
+ <data='<html><head><title>Complex Web Page</tit...'>]
+>>> section_element.generate_css_selector
+'#products'
+>>> section_element.generate_full_css_selector
+'body > main > #products'
+>>> section_element.generate_xpath_selector
+"//*[@id='products']"
+>>> section_element.generate_full_xpath_selector
+"//body/main/*[@id='products']"
+```
+
+## Navigation {#navigation}
+Verwenden Sie die zuvor gefundenen Elemente:
+
+```pycon
+>>> section_element.parent
+<data='<main><section id="products" schema='{"j...' parent='<body> <header><nav><ul><li> <a href="#h...'>
+>>> section_element.parent.tag
+'main'
+>>> section_element.parent.parent.tag
+'body'
+>>> section_element.children
+[<data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>,
+ <data='<div class="product-list"> <article clas...' parent='<section id="products" schema='{"jsonabl...'>]
+>>> section_element.siblings
+[<data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>]
+>>> section_element.next # gets the next element, the same logic applies to `quote.previous`.
+<data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>
+>>> section_element.children.css('h2::text').getall()
+['Products']
+>>> page.css('[data-id="1"]')[0].has_class('product')
+True
+```
+Um über das Elternelement hinauszugehen, können Sie alle Vorfahren eines Elements durchlaufen:
+```python
+for ancestor in section_element.iterancestors():
+ print(ancestor.tag)
+```
+Sie können auch einen Vorfahren suchen, der eine Bedingung erfüllt. Übergeben Sie eine Funktion, die ein `Selector`-Objekt erhält und `True` zurückgibt, wenn es die Bedingung erfüllt, sonst `False`:
+```pycon
+>>> section_element.find_ancestor(lambda ancestor: ancestor.css('nav'))
+<data='<body> <header><nav><ul><li> <a href="#h...' parent='<html><head><title>Complex Web Page</tit...'>
+```
+
+## Webseiten abrufen {#fetching-websites}
+Statt HTML an Scrapling zu übergeben, können Sie die Antwort einer Website über HTTP-Anfragen oder einen Browser abrufen.
+
+Wählen Sie den Fetcher, der zu Ihrer Aufgabe passt.
+
+### HTTP-Anfragen {#http-requests}
+Importieren und verwenden Sie die Klasse `Fetcher`, um HTTP-Anfragen zu senden:
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://scrapling.requestcatcher.com/get', impersonate="chrome")
+```
+Diese Beispiele zeigen die verschiedenen HTTP-Methoden:
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')
+page = Fetcher.put('https://scrapling.requestcatcher.com/put', data={'key': 'value'})
+page = Fetcher.delete('https://scrapling.requestcatcher.com/delete')
+```
+Für asynchrone Anfragen ändern Sie den Import:
+```python
+from scrapling.fetchers import AsyncFetcher
+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')
+page = await AsyncFetcher.put('https://scrapling.requestcatcher.com/put', data={'key': 'value'})
+page = await AsyncFetcher.delete('https://scrapling.requestcatcher.com/delete')
+```
+
+!!! note "Hinweise"
+
+ 1. `stealthy_headers` erzeugt echte Browser-Header, einschließlich eines Google-Referers. Die Option ist standardmäßig aktiv.
+ 2. Mit `impersonate` können Sie den TLS-Fingerprint einer bestimmten Browserversion nachbilden.
+ 3. `http3` aktiviert HTTP/3, damit die Anfragen denen eines echten Browsers stärker ähneln.
+
+Weitere Optionen finden Sie in der [Anleitung zu HTTP-Anfragen](fetching/static.md).
+
+### Dynamisches Laden {#dynamic-loading}
+Sie können auch mit Websites arbeiten, die ihre Inhalte über JavaScript laden.
+
+`StealthyFetcher` bietet viele Optionen zum Abrufen und Laden von Seiten mit Browsern auf Chromium-Basis.
+```python
+from scrapling.fetchers import StealthyFetcher
+page = StealthyFetcher.fetch('https://quotes.toscrape.com/js/', disable_resources=True, block_ads=True, wait_selector='.quote')
+print(len(page.css(".quote"))) # -> 10
+
+# The async version of fetch
+page = await StealthyFetcher.async_fetch('https://quotes.toscrape.com/js/', disable_resources=True, block_ads=True, wait_selector='.quote')
+print(len(page.css(".quote"))) # -> 10
+```
+Er nutzt [Playwright](https://playwright.dev/python/) mit Änderungen, die die Automatisierung verbergen. Verwenden Sie das mitgelieferte Chromium, Ihr installiertes Google Chrome mit `real_chrome=True` oder einen laufenden Browser über `cdp_url`.
+
+### Funktionen gegen Bot-Erkennung {#anti-bot-features}
+
+Dazu gehören:
+
+1. Löst verschiedene Arten von Cloudflare Turnstile und Interstitial automatisch mit `solve_cloudflare=True`.
+2. Verhindert Lecks über die CDP-Runtime und WebRTC.
+3. Isoliert die JavaScript-Ausführung, entfernt viele Spuren von Playwright und verhindert die Erkennung einiger bekannter Bot-Verhaltensweisen.
+4. Fügt dem Canvas Rauschen hinzu, damit er nicht als Browser-Fingerprint verwendet werden kann.
+5. Behebt bekannte Möglichkeiten, Browser ohne grafische Oberfläche zu erkennen, und kann eine Erkennung durch abweichende Zeitzonen verhindern.
+6. Bietet weitere Optionen, um Erkennung zu vermeiden.
+
+```python
+from scrapling.fetchers import StealthyFetcher
+page = StealthyFetcher.fetch('https://www.browserscan.net/bot-detection') # Running headless by default
+page.status == 200 # -> True
+
+page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare', solve_cloudflare=True) # Solve Cloudflare captcha automatically if presented
+page.status == 200 # -> True
+
+page = StealthyFetcher.fetch('https://www.browserscan.net/bot-detection', block_webrtc=True, hide_canvas=True, dns_over_https=True) # and the rest of arguments...
+# The async version of fetch
+page = await StealthyFetcher.async_fetch('https://www.browserscan.net/bot-detection')
+page.status == 200 # -> True
+```
+
+Details und die vollständige Parameterliste stehen in der [Browser-Anleitung](fetching/stealthy.md).
+
+---
+
+Das war ein Überblick über Scrapling. Im nächsten Abschnitt lernen Sie weitere Funktionen kennen.
diff --git a/docs/locales/de/parsing/adaptive.md b/docs/locales/de/parsing/adaptive.md
new file mode 100644
index 0000000..1455318
--- /dev/null
+++ b/docs/locales/de/parsing/adaptive.md
@@ -0,0 +1,232 @@
+---
+title: "HTML-Elemente mit adaptivem Parsing verfolgen und wiederfinden"
+description: "Speichern Sie die Merkmale von Elementen und finden Sie diese nach HTML-Änderungen wieder. Lernen Sie, adaptives Parsing mit save, retrieve und relocate zu nutzen."
+---
+
+# Adaptives Scraping {#adaptive-scraping}
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Elemente auswählen](../parsing/selection.md) gelesen und wissen, wie Sie Elemente in einem [Selector](../parsing/main_classes.md#selector)-Objekt finden und extrahieren.
+ 2. Sie haben die Seite [Hauptklassen](../parsing/main_classes.md) gelesen und kennen die Klasse [Selector](../parsing/main_classes.md#selector).
+
+Adaptives Scraping, früher als automatch bekannt, ist eine der stärksten Funktionen von Scrapling. Es verfolgt Elemente und findet sie wieder, damit Ihr Scraper auch nach Änderungen an einer Website weiter funktioniert.
+
+Angenommen, Sie lesen Daten aus einer Seite mit dieser Struktur aus:
+```html
+<div class="container">
+ <section class="products">
+ <article class="product" id="p1">
+ <h3>Product 1</h3>
+ <p class="description">Description 1</p>
+ </article>
+ <article class="product" id="p2">
+ <h3>Product 2</h3>
+ <p class="description">Description 2</p>
+ </article>
+ </section>
+</div>
+```
+Sie möchten das erste Produkt mit der ID `p1` auslesen. Dafür würden Sie vermutlich diesen Selektor verwenden:
+```python
+page.css('#p1')
+```
+Wenn die Betreiber der Website die Struktur so ändern:
+```html
+<div class="new-container">
+ <div class="product-wrapper">
+ <section class="products">
+ <article class="product new-class" data-id="p1">
+ <div class="product-info">
+ <h3>Product 1</h3>
+ <p class="new-description">Description 1</p>
+ </div>
+ </article>
+ <article class="product new-class" data-id="p2">
+ <div class="product-info">
+ <h3>Product 2</h3>
+ <p class="new-description">Description 2</p>
+ </div>
+ </article>
+ </section>
+ </div>
+</div>
+```
+Dann funktioniert der Selektor nicht mehr, und Sie müssen Ihren Code anpassen. Hier hilft die Funktion `adaptive` von Scrapling.
+
+Mit Scrapling können Sie `adaptive` aktivieren, wenn Sie ein Element zum ersten Mal auswählen. Wenn Sie es später erneut auswählen und es nicht mehr gefunden wird, nutzt Scrapling die gespeicherten Merkmale. Es sucht auf der Website nach dem Element mit der höchsten Ähnlichkeit. Und das ohne KI :)
+
+```python
+from scrapling import Selector, Fetcher
+# Before the change
+page = Selector(page_source, adaptive=True, url='example.com')
+# or
+Fetcher.adaptive = True
+page = Fetcher.get('https://example.com')
+# then
+element = page.css('#p1', auto_save=True)
+if not element: # One day website changes?
+ element = page.css('#p1', adaptive=True) # Scrapling still finds it!
+# the rest of your code...
+```
+Im folgenden Beispiel sehen Sie, wie Sie diese Funktion nutzen. Danach erklären wir die Verwendung und die Details genauer. Sie funktioniert mit allen Auswahlmethoden, nicht nur mit CSS/XPath.
+
+## Beispiel aus der Praxis {#real-world-scenario}
+Nehmen wir eine echte Website und laden ihren Quelltext mit einem Fetcher. Dafür müssten wir eine Website finden, deren Design oder Struktur sich bald ändert. Dann würden wir ihren Quelltext speichern und auf die Änderung warten. Das lässt sich natürlich kaum vorhersagen, außer ich kenne den Betreiber. Dann wäre der Test aber gestellt, haha.
+
+Deshalb nutze ich die [Wayback Machine](https://web.archive.org/) von [The Web Archive](https://archive.org/). Hier ist eine Kopie der [StackOverFlow-Website von 2010](https://web.archive.org/web/20100102003420/http://stackoverflow.com/). Ziemlich alt, oder?</br>Prüfen wir, ob die adaptive Funktion mit demselben Selektor den gleichen Button im alten Design von 2010 und im aktuellen Design findet :)
+
+Um den Button Questions im alten Design auszuwählen, kann ich diesen Selektor nutzen: `#hmenus > div:nth-child(1) > ul > li:nth-child(1) > a`. Er ist sehr genau festgelegt, weil Google Chrome ihn erzeugt hat.
+
+
+Testen wir jetzt denselben Selektor in beiden Versionen:
+```python
+from scrapling import Fetcher
+selector = '#hmenus > div:nth-child(1) > ul > li:nth-child(1) > a'
+old_url = "https://web.archive.org/web/20100102003420/http://stackoverflow.com/"
+new_url = "https://stackoverflow.com/"
+Fetcher.configure(adaptive = True, adaptive_domain='stackoverflow.com')
+page = Fetcher.get(old_url, timeout=30)
+element1 = page.css(selector, auto_save=True)[0]
+# Same selector but used in the updated website
+page = Fetcher.get(new_url)
+element2 = page.css(selector, adaptive=True)[0]
+
+if element1.text == element2.text:
+ print('Scrapling found the same element in the old and new designs!') # Spoiler alert: it does!
+```
+Hier kommt das neue Argument `adaptive_domain` dazu. Für Scrapling sind `archive.org` und `stackoverflow.com` zwei verschiedene Domains. Deshalb speichert es ihre `adaptive`-Daten getrennt. Damit Scrapling beide als dieselbe Website behandelt, geben wir für beide eine gemeinsame Domain zum Speichern der `adaptive`-Daten an.
+
+In der Praxis wäre der Code gleich, aber beide Anfragen hätten dieselbe URL. Dann brauchen Sie das Argument `adaptive_domain` nicht. Dieses Beispiel kommt einem echten Fall so nah wie möglich. Ich hoffe, es hat Sie nicht verwirrt :)
+
+In den beiden Beispielen habe ich die Klassen `Selector` und `Fetcher` verwendet. So sehen Sie, dass die adaptive Logik bei beiden gleich ist.
+
+!!! info
+
+ Das Argument `adaptive_domain` ist vor allem für Websites gedacht, die mit ihrem Design oder ihrer Struktur auch die URL ändern. Sie können damit die gespeicherten adaptiven Daten unter der neuen URL weiter nutzen. Sonst behandelt Scrapling die URL als neue Website und verwendet die alten Daten nicht mehr.
+
+## So funktioniert adaptives Scraping {#how-the-adaptive-scraping-feature-works}
+Adaptives Scraping hat zwei Phasen:
+
+1. **Speichern**: Die besonderen Merkmale der Elemente speichern.
+2. **Abgleichen**: Später Elemente mit ähnlichen Merkmalen finden.
+
+Angenommen, Sie haben ein Element mit einer beliebigen Methode ausgewählt. Die Bibliothek soll es beim nächsten Abruf der Website wiederfinden, auch wenn sich Struktur oder Design geändert haben.
+
+Ohne zu viele technische Details läuft das so ab:
+
+ 1. Sie weisen Scrapling an, die besonderen Merkmale des Elements zu speichern. Die möglichen Wege zeigen wir weiter unten.
+ 2. Scrapling speichert die Merkmale jedes Elements in der eingestellten Datenbank. Standardmäßig ist das SQLite.
+ 3. Die Betreiber der Website können jedes Merkmal eines Elements ändern oder entfernen. Deshalb eignet sich keines davon als feste Kennung in der Datenbank. Das Speichersystem nutzt stattdessen zwei Angaben:
+ 1. Die Domain der aktuellen Website. Bei der Klasse `Selector` geben Sie diese beim Erstellen an. Bei einem Fetcher wird sie automatisch aus der URL übernommen.
+ 2. Einen `identifier`, um die Merkmale des Elements aus der Datenbank abzurufen. Diese Kennung müssen Sie nicht immer selbst festlegen. Dazu später mehr.
+
+ Zusammen dienen beide Angaben dazu, die gespeicherten Merkmale des Elements aus der Datenbank abzurufen.
+
+ 4. Wenn sich die Struktur der Website später ändert, aktivieren Sie `adaptive`, um das Element zu finden. Scrapling lädt seine gespeicherten Merkmale und vergleicht alle Elemente auf der Seite damit. Für jedes Element berechnet es einen Wert für die Ähnlichkeit zum gesuchten Element. Dabei berücksichtigt es alle Merkmale, wie wir gleich sehen.
+ 5. Es gibt die Elemente mit der höchsten Ähnlichkeit zum gesuchten Element zurück.
+
+### Die besonderen Merkmale {#the-unique-properties}
+Vielleicht fragen Sie sich, welche Merkmale hier gemeint sind, wenn sich doch alle Eigenschaften eines Elements ändern oder entfernen lassen.
+
+Scrapling nutzt diese Merkmale:
+
+- Tag-Name, Text, Attribute mit Namen und Werten, Geschwisterelemente mit ihren Tag-Namen und der Pfad mit seinen Tag-Namen.
+- Tag-Name, Attribute mit Namen und Werten sowie Text des übergeordneten Elements.
+
+Der Vergleich sucht nicht nach exakt gleichen Werten, sondern nach ähnlichen. Dabei zählt alles, auch die Reihenfolge der Werte. Das gilt zum Beispiel für die Reihenfolge der Klassennamen eines Elements vor und nach der Änderung.
+
+## Die adaptive Funktion nutzen {#how-to-use-adaptive-feature}
+Sie können die adaptive Funktion auf jedes gefundene Element anwenden. Wie oben gezeigt, steht sie auch über Argumente der CSS/XPath-Auswahlmethoden bereit. Darauf kommen wir gleich zurück.
+
+Zuerst müssen Sie `adaptive` aktivieren. Übergeben Sie dazu `adaptive=True`, wenn Sie eine Instanz der Klasse [Selector](main_classes.md#selector) erstellen. Oder aktivieren Sie die Funktion im verwendeten Fetcher, wie wir gleich zeigen.
+
+Beispiele:
+```python
+from scrapling import Selector, Fetcher
+page = Selector(html_doc, adaptive=True)
+# OR
+Fetcher.adaptive = True
+page = Fetcher.get('https://example.com')
+```
+Wenn Sie die Klasse [Selector](main_classes.md#selector) nutzen, geben Sie mit `url` die URL der Website an. Damit kann Scrapling die gespeicherten Merkmale nach Domain trennen.
+
+Ohne URL wird beim Speichern der Merkmale das Wort `default` als URL-Wert verwendet. Das wird nur dann zum Problem, wenn Sie später dieselbe Kennung für eine andere Website nutzen und beim Erstellen wieder keine URL angeben. Das Speichern überschreibt die bisherigen Daten. Die Funktion `adaptive` nutzt immer die zuletzt gespeicherten Merkmale.
+
+Außerdem gibt es `storage` und `storage_args`. Diese Argumente legen die Verbindung zur Datenbank fest. Standardmäßig wird die SQLite-Klasse der Bibliothek verwendet. Sie brauchen diese Argumente nur, wenn Sie ein eigenes Speichersystem schreiben möchten. Das erklären wir auf einer [eigenen Seite im Entwicklungsbereich](../development/adaptive_storage_system.md).
+
+Nachdem Sie `adaptive` global aktiviert haben, können Sie die Funktion auf zwei Arten nutzen.
+
+### Mit CSS/XPath auswählen {#the-cssxpath-selection-way}
+Wie im Beispiel oben wählen Sie zuerst ein vorhandenes Element mit dem Argument `auto_save` aus:
+```python
+element = page.css('#p1', auto_save=True)
+```
+Wenn das Element später nicht mehr gefunden wird, verwenden Sie denselben Selektor mit `adaptive`. Die Bibliothek sucht es dann für Sie:
+```python
+element = page.css('#p1', adaptive=True)
+```
+Ziemlich einfach, oder?
+
+Im Hintergrund passiert dabei einiges. Erinnern Sie sich an die Kennung, mit der Sie die Merkmale des gewünschten Elements abrufen? Bei den Methoden `css`/`xpath` wird dafür automatisch der übergebene Selektor verwendet. Das macht die Nutzung einfacher :)
+
+Sie können bei all diesen Methoden auch `identifier` übergeben und die Kennung selbst festlegen. Das ist in manchen Fällen hilfreich. Sie können diese Kennung auch zusammen mit `auto_save` zum Speichern der Merkmale nutzen.
+
+### Manuell vorgehen {#the-manual-way}
+Sie können ein Element selbst speichern, seine Merkmale abrufen und es dann wiederfinden. Auch das geschieht mit `adaptive`, wie unten gezeigt. So können Sie jedes Element wiederfinden, unabhängig von der verwendeten Auswahlmethode!
+
+Angenommen, Sie haben ein Element über seinen Text gefunden:
+```python
+element = page.find_by_text('Tipping the Velvet', first_match=True)
+```
+Mit der Methode `save` speichern Sie seine besonderen Merkmale. Dabei müssen Sie die Kennung selbst festlegen. Hier verwende ich `my_special_element`. Wählen Sie in Ihrem Code einen aussagekräftigen Namen, genau wie bei Variablen :)
+```python
+page.save(element, 'my_special_element')
+```
+Wenn Sie die Merkmale später abrufen und das Element mit `adaptive` auf der Seite wiederfinden möchten, geht das so:
+```python
+>>> element_dict = page.retrieve('my_special_element')
+>>> page.relocate(element_dict, selector_type=True)
+[<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>]
+>>> page.relocate(element_dict, selector_type=True).css('::text').getall()
+['Tipping the Velvet']
+```
+Dafür werden also die Methoden `retrieve` und `relocate` verwendet.
+
+Wenn Sie das Ergebnis als `lxml.etree`-Objekt behalten möchten, lassen Sie das Argument `selector_type` weg:
+```python
+>>> page.relocate(element_dict)
+[<Element a at 0x105a2a7b0>]
+```
+
+## Fehler beheben {#troubleshooting}
+
+### Keine Treffer gefunden {#no-matches-found}
+```python
+# 1. Check if data was saved
+element_data = page.retrieve('identifier')
+if not element_data:
+ print("No data saved for this identifier")
+
+# 2. Try with different identifier
+products = page.css('.product', adaptive=True, identifier='old_selector')
+
+# 3. Save again with new identifier
+products = page.css('.new-product', auto_save=True, identifier='new_identifier')
+```
+
+### Falsche Elemente gefunden {#wrong-elements-matched}
+```python
+# Use more specific selectors
+products = page.css('.product-list .product', auto_save=True)
+
+# Or save with more context
+product = page.find_by_text('Product Name').parent
+page.save(product, 'specific_product')
+```
+
+## Bekannte Probleme {#known-issues}
+Beim Speichern mit `adaptive` werden nur die besonderen Merkmale des ersten Elements im Auswahlergebnis gespeichert. Wenn Ihr Selektor verschiedene Elemente an mehreren Stellen der Seite auswählt, findet `adaptive` später nur das erste davon wieder. Das gilt nicht für kombinierte CSS-Selektoren, zum Beispiel mehrere mit Kommas getrennte Selektoren. Diese werden einzeln ausgeführt.
+
+## Zum Schluss {#final-thoughts}
+Diese Funktion genau und trotzdem einfach zu erklären, war nicht leicht. Falls etwas unklar bleibt, schreiben Sie im [Diskussionsbereich](https://github.com/D4Vinci/Scrapling/discussions). Ich antworte so schnell wie möglich. Sie können auch den Discord-Server nutzen oder mir direkt schreiben :)
\ No newline at end of file
diff --git a/docs/locales/de/parsing/main_classes.md b/docs/locales/de/parsing/main_classes.md
new file mode 100644
index 0000000..0ac6d54
--- /dev/null
+++ b/docs/locales/de/parsing/main_classes.md
@@ -0,0 +1,573 @@
+---
+title: "Scrapling Selector und Selectors: Daten und Navigation"
+description: "Erfahren Sie, wie Selector und Selectors HTML, Text und Attribute speichern. Lesen Sie Werte aus, lösen Sie URLs auf und wechseln Sie zwischen Eltern-, Kind- und Geschwisterelementen."
+---
+
+# Hauptklassen des Parsers {#parsing-main-classes}
+
+!!! success "Voraussetzungen"
+
+ - Sie haben die Seite [Elemente auswählen](../parsing/selection.md) gelesen und wissen, wie Sie Elemente in einem [Selector](../parsing/main_classes.md#selector)-Objekt finden und extrahieren.
+
+Sie kennen nun die verschiedenen Möglichkeiten, Elemente mit Scrapling auszuwählen. Sehen wir uns jetzt die Klasse [Selector](#selector) und die anderen Objekte genauer an, um den Parser besser zu verstehen.
+
+Die Klasse [Selector](#selector) bildet den Kern des Parsers von Scrapling. Sie analysiert HTML und wählt Elemente aus. Sie können sie auf eine dieser Arten importieren:
+```python
+from scrapling import Selector
+from scrapling.parser import Selector
+```
+Danach verwenden Sie sie direkt, wie auf der Seite [Überblick](../overview.md) gezeigt:
+```python
+page = Selector(
+ '<html>...</html>',
+ url='https://example.com'
+)
+
+# Then select elements as you like
+elements = page.css('.product')
+```
+Wenn Sie HTML übergeben oder eine Website abrufen, arbeiten Sie in Scrapling vor allem mit einem [Selector](#selector)-Objekt. Operationen wie Auswahl und Navigation geben ein [Selector](#selector)- oder [Selectors](#selectors)-Objekt zurück, wenn das Ergebnis ein oder mehrere Seitenelemente sind und kein Text oder Ähnliches.
+
+Die gesamte Seite ist also ein [Selector](#selector)-Objekt. Ihre Elemente sind ebenfalls [Selector](#selector)-Objekte. Text, etwa der Inhalt eines Elements oder ein Attributwert, ist ein [TextHandler](#texthandler)-Objekt. Die Attribute eines Elements werden in einem [AttributesHandler](#attributeshandler) gespeichert. Auf beide kommen wir später zurück. Zuerst sehen wir uns [Selector](#selector) an.
+
+## Selector {#selector}
+### Die Argumente erklärt {#arguments-explained}
+Das wichtigste Argument ist `content`. Damit übergeben Sie den HTML-Code, den Sie analysieren möchten, als `str` oder `bytes`.
+
+Mit `url` legen Sie die Seiten-URL fest. Sie dient dazu, relative Links aufzulösen und gespeicherte adaptive Daten nach Domain zu trennen. Die Argumente `adaptive`, `storage` und `storage_args` gehören zur Funktion [adaptive](adaptive.md). Wenn Sie diese nicht nutzen, haben die Argumente keine Auswirkung.
+
+Weitere Argumente steuern, wie der Parser den HTML-Inhalt verarbeitet oder dabei verändert:
+
+- **encoding**: Die Zeichenkodierung, die beim Analysieren des HTML verwendet wird. Der Standardwert ist `UTF-8`.
+- **keep_comments**: Legt fest, ob HTML-Kommentare beim Analysieren erhalten bleiben. Standardmäßig ist dies deaktiviert, weil Kommentare das Scraping auf verschiedene Arten stören können.
+
+Die Argumente `huge_tree` und `root` lasse ich hier bewusst weg, damit diese Seite nicht unnötig kompliziert wird.
+Das mache ich öfter bei fortgeschrittenen Funktionen, die Sie für die normale Nutzung nicht kennen müssen. Wenn Sie mehr wissen möchten, finden Sie diese Themen im Entwicklungsbereich.
+
+Die meisten Eigenschaften der Seite und ihrer Elemente werden erst geladen, wenn Sie sie verwenden. Das gilt zum Beispiel für den Textinhalt. Auch deshalb ist Scrapling so schnell :)
+
+### Eigenschaften {#properties}
+Vieles davon kennen Sie schon aus dem [Überblick](../overview.md). Falls nicht, ist das kein Problem. Wir gehen es hier mit weiteren Methoden und Beispielen durch. Die Eigenschaften zur Navigation stehen getrennt im Abschnitt [Navigation](#traversal).
+
+Für die Beispiele verwenden wir diese HTML-Seite:
+```html
+<html>
+ <head>
+ <title>Some page</title>
+ </head>
+ <body>
+ <div class="product-list">
+ <article class="product" data-id="1">
+ <h3>Product 1</h3>
+ <p class="description">This is product 1</p>
+ <span class="price">$10.99</span>
+ <div class="hidden stock">In stock: 5</div>
+ </article>
+
+ <article class="product" data-id="2">
+ <h3>Product 2</h3>
+ <p class="description">This is product 2</p>
+ <span class="price">$20.99</span>
+ <div class="hidden stock">In stock: 3</div>
+ </article>
+
+ <article class="product" data-id="3">
+ <h3>Product 3</h3>
+ <p class="description">This is product 3</p>
+ <span class="price">$15.99</span>
+ <div class="hidden stock">Out of stock</div>
+ </article>
+ </div>
+
+ <script id="page-data" type="application/json">
+ {
+ "lastUpdated": "2024-09-22T10:30:00Z",
+ "totalProducts": 3
+ }
+ </script>
+ </body>
+</html>
+```
+Laden Sie die Seite direkt wie zuvor:
+```python
+from scrapling import Selector
+page = Selector(html_doc)
+```
+Lesen Sie den gesamten Text der Seite einschließlich aller untergeordneten Elemente aus:
+```python
+>>> page.get_all_text()
+'Some page\n\n \n\n \nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock'
+```
+Wählen Sie wie zuvor den ersten Artikel aus. Er dient uns als Beispiel:
+```python
+article = page.find('article')
+```
+Auf dieselbe Weise lesen Sie den gesamten Text des Elements und seiner untergeordneten Elemente aus:
+```python
+>>> article.get_all_text()
+'Product 1\nThis is product 1\n$10.99\nIn stock: 5'
+```
+Der direkte Textinhalt ist dagegen leer, weil das Element im HTML oben keinen eigenen Text enthält:
+```python
+>>> article.text
+''
+```
+Die Methode `get_all_text` hat folgende optionale Argumente:
+
+1. **separator**: Verbindet alle gesammelten Zeichenketten mit diesem Trennzeichen. Der Standardwert ist '\n'.
+2. **strip**: Entfernt vor dem Verbinden Leerraum am Anfang und Ende der Zeichenketten. Standardmäßig deaktiviert.
+3. **ignore_tags**: Ein Tupel mit den Tag-Namen, die in den Ergebnissen fehlen sollen. Auch darin verschachtelte Elemente werden ignoriert. Der Standardwert ist `('script', 'style',)`.
+4. **valid_values**: Sammelt nur Elemente mit Inhalt. Elemente mit leerem Text oder nur Leerraum werden ignoriert. Standardmäßig aktiviert.
+
+Der zurückgegebene Text ist übrigens keine normale Zeichenkette, sondern ein [TextHandler](#texthandler). Dazu später mehr. Wenn der Text JSON enthält, können Sie `.json()` darauf aufrufen:
+```python
+>>> script = page.find('script')
+>>> script.json()
+{'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
+```
+Lesen Sie jetzt den Tag-Namen des Elements aus:
+```python
+>>> article.tag
+'article'
+```
+Wenn Sie dies direkt auf die Seite anwenden, arbeiten Sie mit dem Wurzelelement `html`:
+```python
+>>> page.tag
+'html'
+```
+Damit sollte der Zusammenhang zwischen `page` und `element` klar sein. Darauf komme ich nicht noch einmal zurück.
+
+Lesen Sie die Attribute des Elements aus:
+```python
+>>> print(article.attrib)
+{'class': 'product', 'data-id': '1'}
+```
+Greifen Sie auf ein bestimmtes Attribut zu:
+```python
+article.attrib['class']
+article.attrib.get('class')
+article['class'] # new in v0.3
+```
+Prüfen Sie mit einer der folgenden Methoden, ob ein Attribut vorhanden ist:
+```python
+'class' in article.attrib
+'class' in article # new in v0.3
+```
+Lesen Sie den HTML-Inhalt des Elements aus:
+```python
+>>> article.html_content
+'<article class="product" data-id="1"><h3>Product 1</h3>\n <p class="description">This is product 1</p>\n <span class="price">$10.99</span>\n <div class="hidden stock">In stock: 5</div>\n </article>'
+```
+Geben Sie den HTML-Inhalt des Elements in gut lesbarer Form aus:
+```python
+print(article.prettify())
+```
+```html
+<article class="product" data-id="1"><h3>Product 1</h3>
+ <p class="description">This is product 1</p>
+ <span class="price">$10.99</span>
+ <div class="hidden stock">In stock: 5</div>
+</article>
+```
+Mit `.body` erhalten Sie den unverarbeiteten Seiteninhalt. Seit v0.4 gibt `.body` bei einem `Response`-Objekt eines Fetchers immer `bytes` zurück.
+```python
+>>> page.body
+'<html>\n <head>\n <title>Some page</title>\n </head>\n ...'
+```
+So erhalten Sie alle Vorfahren dieses Elements im DOM-Baum:
+```python
+>>> article.path
+[<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>,
+ <data='<body> <div class="product-list"> <artic...' parent='<html><head><title>Some page</title></he...'>,
+ <data='<html><head><title>Some page</title></he...'>]
+```
+Erzeugen Sie einen möglichst kurzen CSS-Selektor oder den vollständigen Selektor:
+```python
+>>> article.generate_css_selector
+'body > div > article'
+>>> article.generate_full_css_selector
+'body > div > article'
+```
+Das geht auch mit XPath:
+```python
+>>> article.generate_xpath_selector
+"//body/div/article"
+>>> article.generate_full_xpath_selector
+"//body/div/article"
+```
+
+### Navigation {#traversal}
+Mit den oben gefundenen Elementen sehen wir uns nun die Eigenschaften und Methoden zur Navigation auf der Seite an.
+
+Wenn Sie den DOM-Baum oder Baumstrukturen noch nicht kennen, kann dieser Abschnitt schwer verständlich sein. Ich empfehle, sich zuerst kurz über diese Begriffe zu informieren.
+
+Falls Sie nicht suchen möchten, hier eine kurze Erklärung.<br/>
+Das Element `html` ist die Wurzel des Seitenbaums. Jede Seite beginnt mit einem `html`-Element.<br/>
+Direkt darunter liegen Elemente wie `head` und `body`. Sie sind die „Kinder“ von `html`, und `html` ist ihr „Elternteil“. Die Elemente `body` und `head` sind „Geschwister“, weil sie dasselbe Elternelement haben.
+
+Greifen Sie auf das Elternelement zu:
+```python
+>>> article.parent
+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>
+>>> article.parent.tag
+'div'
+```
+Sie können diese Zugriffe beliebig verketten. Das gilt auch für die anderen ähnlichen Eigenschaften und Methoden in diesem Abschnitt.
+```python
+>>> article.parent.parent.tag
+'body'
+```
+Lesen Sie die Kindelemente aus:
+```python
+>>> article.children
+[<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>]
+```
+Lesen Sie alle Elemente unterhalb eines Elements aus. Das entspricht einer verschachtelten Version von `children`:
+```python
+>>> article.below_elements
+[<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>]
+```
+Bei diesem Element ist das Ergebnis gleich wie bei `children`, weil seine Kinder keine weiteren Kinder haben.
+
+Am Element mit der Klasse `product-list` wird der Unterschied zwischen `children` und `below_elements` deutlicher:
+```python
+>>> products_list = page.css('.product-list')[0]
+>>> products_list.children
+[<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+
+>>> products_list.below_elements
+[<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
+...]
+```
+Lesen Sie die Geschwisterelemente aus:
+```python
+>>> article.siblings
+[<data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+```
+Lesen Sie das nächste Geschwisterelement aus:
+```python
+>>> article.next
+<data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>
+```
+Für das vorherige Element gibt es `previous`:
+```python
+>>> article.previous # It's the first child, so it doesn't have a previous element
+>>> second_article = page.css('.product[data-id="2"]')[0]
+>>> second_article.previous
+<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>
+```
+Sie können einfach und schnell prüfen, ob ein Element einen bestimmten Klassennamen hat:
+```python
+>>> article.has_class('product')
+True
+```
+Wenn Sie mehr als das direkte Elternelement brauchen, können Sie alle Vorfahren eines Elements durchlaufen:
+```python
+for ancestor in article.iterancestors():
+ # do something with it...
+```
+Sie können auch einen Vorfahren suchen, der eine Bedingung erfüllt. Übergeben Sie eine Funktion, die ein [Selector](#selector)-Objekt annimmt und `True` zurückgibt, wenn die Bedingung erfüllt ist, sonst `False`:
+```python
+>>> article.find_ancestor(lambda ancestor: ancestor.has_class('product-list'))
+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>
+
+>>> article.find_ancestor(lambda ancestor: ancestor.css('.product-list')) # Same result, different approach
+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>
+```
+## Selectors {#selectors}
+Die Klasse `Selectors` ist die Listenvariante von [Selector](#selector). Sie erbt vom Python-Standardtyp `List` und besitzt alle Eigenschaften und Methoden von `List`. Zusätzliche Methoden vereinfachen die Arbeit mit den enthaltenen [Selector](#selector)-Instanzen.
+
+Alle Methoden und Eigenschaften von [Selector](#selector), die mehrere Elemente zurückgeben, liefern diese als [Selectors](#selectors)-Instanz.
+
+Seit v0.4 geben alle Auswahlmethoden durchgehend [Selector](#selector)- oder [Selectors](#selectors)-Objekte zurück, auch für Textknoten und Attributwerte. Textknoten, die Sie mit `::text`, `/text()`, `::attr()` oder `/@attr` auswählen, werden in [Selector](#selector)-Objekte verpackt. Bei diesen ist `tag` auf `"#text"` gesetzt, und `text` gibt den Textwert zurück. Sie können weiterhin direkt auf den Textwert zugreifen. Alle anderen Eigenschaften liefern leere Werte oder Standardwerte.
+
+```python
+page.css('a::text') # -> Selectors (of text node Selectors)
+page.xpath('//a/text()') # -> Selectors
+page.css('a::text').get() # -> TextHandler (the first text value)
+page.css('a::text').getall() # -> TextHandlers (all text values)
+page.css('a::attr(href)') # -> Selectors
+page.xpath('//a/@href') # -> Selectors
+page.css('.price_color') # -> Selectors
+```
+
+### Methoden zum Auslesen von Daten {#data-extraction-methods}
+Seit v0.4 bieten [Selector](#selector) und [Selectors](#selectors) die Methoden `get()`, `getall()` sowie die Aliase `extract_first` und `extract`. Sie folgen damit den Konventionen von Scrapy. Die alte Methode `get_all()` wurde entfernt.
+
+**Bei einem [Selector](#selector)-Objekt:**
+
+- `get()` gibt einen `TextHandler` zurück. Bei Textknoten enthält er den Textwert, bei HTML-Elementen das serialisierte äußere HTML einschließlich des Elements selbst.
+- `getall()` gibt eine `TextHandlers`-Liste mit dieser einen serialisierten Zeichenkette zurück.
+- `extract_first` ist ein Alias für `get()`, und `extract` ist ein Alias für `getall()`.
+
+```python
+>>> page.css('h3')[0].get() # Outer HTML of the element
+'<h3>Product 1</h3>'
+
+>>> page.css('h3::text')[0].get() # Text value of the text node
+'Product 1'
+```
+
+**Bei einem [Selectors](#selectors)-Objekt:**
+
+- `get(default=None)` gibt die serialisierte Zeichenkette des **ersten** Elements zurück. Ist die Liste leer, wird `default` zurückgegeben.
+- `getall()` serialisiert **alle** Elemente und gibt eine `TextHandlers`-Liste zurück.
+- `extract_first` ist ein Alias für `get()`, und `extract` ist ein Alias für `getall()`.
+
+```python
+>>> page.css('.price::text').get() # First price text
+'$10.99'
+
+>>> page.css('.price::text').getall() # All price texts
+['$10.99', '$20.99', '$15.99']
+
+>>> page.css('.price::text').get('') # With default value
+'$10.99'
+```
+
+Diese Methoden funktionieren mit allen Auswahlarten wie CSS, XPath und `find`. Sie sind der empfohlene Weg, Text und Attributwerte im Stil von Scrapy auszulesen.
+
+Sehen wir uns nun die weiteren Funktionen von [Selectors](#selectors) an.
+### Eigenschaften {#properties_1}
+Neben den normalen Listenoperationen wie Iteration und Slicing stehen diese Möglichkeiten bereit:
+
+Sie können CSS- und XPath-Selektoren direkt auf die enthaltenen [Selector](#selector)-Instanzen anwenden. Die Rückgabetypen entsprechen denen der Methoden `css` und `xpath` von [Selector](#selector). Die Argumente sind ähnlich, aber `adaptive` steht hier nicht zur Verfügung. So lassen sich Methoden einfach verketten.
+```pycon
+>>> page.css('.product h3::text').getall()
+['Product 1', 'Product 2', 'Product 3']
+>>> page.css('.product').css('h3::text').getall()
+['Product 1', 'Product 2', 'Product 3']
+```
+Auch `re` und `re_first` lassen sich direkt aufrufen. Sie nehmen dieselben Argumente an wie bei [Selector](#selector). Die Erklärung dieser Methoden folgt im Abschnitt [TextHandler](#texthandler).
+
+In dieser Klasse verhält sich `re_first` etwas anders: Es führt `re` auf jedem enthaltenen [Selector](#selector) aus und gibt das erste gefundene Ergebnis zurück. Die Methode `re` liefert wie gewohnt ein [TextHandlers](#texthandlers)-Objekt. Darin werden alle [TextHandler](#texthandler)-Instanzen in einer [TextHandlers](#texthandlers)-Instanz zusammengeführt.
+```pycon
+>>> page.css('.price::text').re(r'[\d.]+')
+['10.99', '20.99', '15.99']
+>>> page.css('.product h3::text').re(r'Product (\d+)')
+['1', '2', '3']
+```
+Mit `search` durchsuchen Sie die enthaltenen [Selector](#selector)-Instanzen. Die übergebene Funktion muss als erstes Argument eine [Selector](#selector)-Instanz annehmen und True oder False zurückgeben. Die Methode liefert die erste [Selector](#selector)-Instanz, die die Bedingung erfüllt, sonst `None`.
+
+```pycon
+>>> product = page.css('.product').search(lambda p: p.css('.price::text').get() == '$20.99')
+>>> product.css('h3::text').get()
+'Product 2'
+```
+Auch `filter` nimmt eine Funktion wie `search` an. Es gibt aber eine `Selectors`-Instanz mit allen passenden [Selector](#selector)-Instanzen zurück:
+
+```pycon
+>>> products = page.css('.product').filter(lambda p: float(p.css('.price::text').re_first(r'[\d.]+')) > 15)
+>>> products.css('h3::text').getall()
+['Product 2', 'Product 3']
+```
+Sie können sicher auf das erste oder letzte Element zugreifen, ohne einen Indexfehler zu riskieren:
+```python
+>>> page.css('.product').first # First Selector or None
+<data='<article class="product" data-id="1"><h3...'>
+>>> page.css('.product').last # Last Selector or None
+<data='<article class="product" data-id="3"><h3...'>
+>>> page.css('.nonexistent').first # Returns None instead of raising IndexError
+```
+
+Wenn Sie wie ich einen kurzen Weg bevorzugen und wissen möchten, wie viele [Selector](#selector)-Instanzen eine [Selectors](#selectors)-Instanz enthält, geht das so:
+```python
+page.css('.product').length
+```
+Das entspricht:
+```python
+len(page.css('.product'))
+```
+Ja, wie in JavaScript :)
+
+## TextHandler {#texthandler}
+Diese Klasse sollten Sie kennen. Alle Methoden und Eigenschaften, die eine Zeichenkette zurückgeben, liefern einen `TextHandler`. Für Listen von Zeichenketten wird stattdessen [TextHandlers](#texthandlers) verwendet.
+
+TextHandler erbt von der normalen Python-Zeichenkette. Sie können damit also alles tun, was mit einer Python-Zeichenkette möglich ist. Warum hat die Klasse dann einen eigenen Namen?
+
+TextHandler bietet zusätzliche Methoden und Eigenschaften. Diese sehen wir uns jetzt an. Da die Klassen überall TextHandler statt normaler Zeichenketten zurückgeben, lassen sich diese Funktionen oft kombinieren. So wird Ihr Code kürzer und übersichtlicher. Sie können die Klasse auch direkt importieren und auf beliebige Zeichenketten anwenden. Das erklären wir [später](../development/scrapling_custom_types.md).
+### Verwendung {#usage}
+Alle Operationen wie Slicing und Indexzugriffe sowie Methoden wie `split`, `replace` und `strip` geben wieder einen `TextHandler` zurück. Sie können sie also beliebig verketten. Falls Sie eine Methode oder Eigenschaft finden, die statt `TextHandler` eine normale Zeichenkette zurückgibt, öffnen Sie bitte ein Issue. Dann passen wir auch diese an.
+
+Beginnen wir mit `re` und `re_first`. Diese Methoden gibt es auch in [Selector](#selector), [Selectors](#selectors) und [TextHandlers](#texthandlers). Sie nehmen überall dieselben Argumente an.
+
+- Die Methode `re` nimmt als erstes Argument eine Zeichenkette oder ein kompiliertes Regex-Muster an. Sie sucht alle passenden Zeichenketten und gibt sie als [TextHandlers](#texthandlers)-Instanz zurück. `re_first` nimmt dieselben Argumente an und arbeitet ähnlich, gibt aber nur den ersten Treffer als `TextHandler` zurück.
+
+ Weitere hilfreiche Argumente sind:
+
+ - **replace_entities**: Standardmäßig aktiviert. Ersetzt Zeichenreferenzen durch die entsprechenden Zeichen.
+ - **clean_match**: Standardmäßig deaktiviert. Ignoriert bei der Suche alle Leerraumzeichen, auch aufeinanderfolgende Leerzeichen.
+ - **case_sensitive**: Standardmäßig aktiviert. Wenn Sie es deaktivieren, unterscheidet die Regex beim Kompilieren nicht zwischen Groß- und Kleinschreibung.
+
+ Diese Beispiele kennen Sie schon. Das Ergebnis ist ein [TextHandlers](#texthandlers)-Objekt, weil wir `re` verwenden.
+ ```pycon
+ >>> page.css('.price::text').re(r'[\d.]+')
+ ['10.99', '20.99', '15.99']
+ >>> page.css('.product h3::text').re(r'Product (\d+)')
+ ['1', '2', '3']
+ ```
+ Um die weiteren Argumente zu zeigen, verwenden wir für jedes Beispiel eine eigene Zeichenkette:
+ ```python
+ >>> from scrapling import TextHandler
+ >>> test_string = TextHandler('hi there') # Hence the two spaces
+ >>> test_string.re('hi there')
+ >>> test_string.re('hi there', clean_match=True) # Using `clean_match` will clean the string before matching the regex
+ ['hi there']
+
+ >>> test_string2 = TextHandler('Oh, Hi Mark')
+ >>> test_string2.re_first('oh, hi Mark')
+ >>> test_string2.re_first('oh, hi Mark', case_sensitive=False) # Hence disabling `case_sensitive`
+ 'Oh, Hi Mark'
+
+ # Mixing arguments
+ >>> test_string.re('hi there', clean_match=True, case_sensitive=False)
+ ['hi there']
+ ```
+ Da Zeichenketten überall durch `TextHandler` ersetzt werden, geben auch Eigenschaften wie `html_content` einen `TextHandler` zurück. Deshalb können Sie Regex direkt auf den HTML-Inhalt anwenden:
+ ```python
+ >>> page.html_content.re('div class=".*">(.*)</div')
+ ['In stock: 5', 'In stock: 3', 'Out of stock']
+ ```
+
+- Die Methode `.json()` wandelt den Inhalt schnell in ein JSON-Objekt um, wenn dies möglich ist. Sonst löst sie einen Fehler aus:
+ ```python
+ >>> page.css('#page-data::text').get()
+ '\n {\n "lastUpdated": "2024-09-22T10:30:00Z",\n "totalProducts": 3\n }\n '
+ >>> page.css('#page-data::text').get().json()
+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
+ ```
+ Wenn Sie bei der Auswahl keinen Textknoten angeben, etwa den Textinhalt oder einen Attributwert, wird automatisch der Textinhalt verwendet:
+ ```python
+ >>> page.css('#page-data')[0].json()
+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
+ ```
+ Die Klasse [Selector](#selector) bietet hier noch eine weitere Funktion. Angenommen, wir arbeiten mit dieser Seite:
+ ```html
+ <html>
+ <body>
+ <div>
+ <script id="page-data" type="application/json">
+ {
+ "lastUpdated": "2024-09-22T10:30:00Z",
+ "totalProducts": 3
+ }
+ </script>
+ </div>
+ </body>
+ </html>
+ ```
+ Die Methode `get_all_text` der Klasse [Selector](#selector) kennen Sie bereits. Auch sie gibt einen `TextHandler` zurück.<br/><br/>
+ Wenn Sie Folgendes versuchen:
+ ```python
+ >>> page.css('div::text').get().json()
+ ```
+ erhalten Sie einen Fehler. Das `div`-Tag enthält keinen direkten Text, der sich als JSON lesen lässt. Es hat überhaupt keinen direkten Textinhalt.<br/><br/>
+ Hier hilft `get_all_text`:
+ ```python
+ >>> page.css('div')[0].get_all_text(ignore_tags=[]).json()
+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
+ ```
+ Ich verwende hier `ignore_tags`, weil dessen Standardwert `('script', 'style',)` ist.<br/><br/>
+ Ein ähnliches Verhalten gibt es bei Fetchern, die wir später erklären. Angenommen, Sie erhalten diese JSON-Antwort:
+ ```python
+ >>> page = Selector("""{"some_key": "some_value"}""")
+ ```
+ Die Klasse [Selector](#selector) ist für HTML-Seiten optimiert. Sie behandelt die Antwort deshalb wie fehlerhaftes HTML und korrigiert sie. Bei `html_content` erhalten Sie dann Folgendes:
+ ```python
+ >>> page.html_content
+ '<html><body><p>{"some_key": "some_value"}</p></body></html>'
+ ```
+ Die Methode `json` können Sie trotzdem direkt nutzen:
+ ```python
+ >>> page.json()
+ {'some_key': 'some_value'}
+ ```
+ Vielleicht fragen Sie sich, warum das funktioniert, obwohl das `html`-Tag keinen direkten Text enthält.<br/>
+ Für Fälle wie JSON-Antworten behält [Selector](#selector) eine unveränderte Kopie des empfangenen Inhalts. Wenn Sie `.json()` aufrufen, wird zuerst diese Kopie geprüft und als JSON gelesen. Ist keine Kopie vorhanden, etwa bei einzelnen Elementen, wird deren direkter Text geprüft. Andernfalls verwendet die Methode `get_all_text`.<br/>
+
+- Die Methode `.clean()` entfernt Leerraumzeichen und aufeinanderfolgende Leerzeichen. Sie gibt eine neue `TextHandler`-Instanz zurück:
+```python
+>>> TextHandler('\n wonderful idea, \reh?').clean()
+'wonderful idea, eh?'
+```
+Mit `remove_entities` können Sie außerdem festlegen, dass `clean` HTML-Entitäten durch ihre entsprechenden Zeichen ersetzt.
+
+- Die Methode `.sort()` sortiert die Zeichenkette, ähnlich wie bei Listen:
+```python
+>>> TextHandler('acb').sort()
+'abc'
+```
+Das geht auch in umgekehrter Reihenfolge:
+```python
+>>> TextHandler('acb').sort(reverse=True)
+'cba'
+```
+
+Mit der Zeit kommen weitere Methoden und Eigenschaften hinzu. Denken Sie daran, dass diese Klasse fast überall in der Bibliothek anstelle normaler Zeichenketten zurückgegeben wird.
+
+## TextHandlers {#texthandlers}
+Diese Klasse folgt demselben Prinzip wie [Selectors](#selectors) und [Selector](#selector). Sie übernimmt das Verhalten normaler Listen und ergänzt die Methoden `re` und `re_first`.
+
+Der einzige Unterschied: `re_first` führt hier `re` auf jedem [TextHandler](#texthandler) aus und gibt den ersten Treffer oder `None` zurück. Mehr müssen Sie dazu vorerst nicht wissen. Weitere Methoden kommen später hinzu.
+
+## AttributesHandler {#attributeshandler}
+Dies ist eine schreibgeschützte Variante des normalen Python-Dictionarys, also `dict`. Sie speichert die Attribute eines Elements beziehungsweise einer [Selector](#selector)-Instanz.
+```python
+>>> print(page.find('script').attrib)
+{'id': 'page-data', 'type': 'application/json'}
+>>> type(page.find('script').attrib).__name__
+'AttributesHandler'
+```
+Weil sie schreibgeschützt ist, benötigt sie weniger Ressourcen als ein normales Dictionary. Sie bietet dessen Methoden und Eigenschaften, außer denen, die Daten ändern oder überschreiben.
+
+Dazu kommen zwei einfache Funktionen:
+
+- Die Methode `search_values`
+
+ Bei normalen Dictionarys können Sie mit `dict.get("key_name")` prüfen, ob ein Schlüssel vorhanden ist. Für eine Suche nach Werten brauchen Sie sonst zusätzlichen Code. Diese Methode übernimmt das: Sie durchsucht die Attributwerte und liefert für jeden Treffer ein Dictionary.
+
+ Ein einfaches Beispiel:
+ ```python
+ >>> for i in page.find('script').attrib.search_values('page-data'):
+ print(i)
+ {'id': 'page-data'}
+ ```
+ Mit dem Argument `partial` können Sie auch nach einem Teil des Werts suchen:
+ ```python
+ >>> for i in page.find('script').attrib.search_values('page', partial=True):
+ print(i)
+ {'id': 'page-data'}
+ ```
+ Diese Beispiele sind eher theoretisch. In der Praxis könnten Sie die Methode zusammen mit `find_all` nutzen, um alle Elemente mit einem bestimmten Attributwert zu finden:
+ ```python
+ >>> page.find_all(lambda element: list(element.attrib.search_values('product')))
+ [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+ ```
+ Bei all diesen Elementen hat das Attribut `class` den Wert 'product'.
+
+ Hier nutze ich `list`, weil `search_values` einen Generator zurückgibt. Dieser würde sonst für jedes Element als `True` gelten.
+
+- Die Eigenschaft `json_string`
+
+ Diese Eigenschaft wandelt die aktuellen Attribute in eine JSON-Zeichenkette um, wenn sie sich als JSON serialisieren lassen. Sonst löst sie einen Fehler aus.
+
+ ```python
+ >>>page.find('script').attrib.json_string
+ b'{"id":"page-data","type":"application/json"}'
+ ```
\ No newline at end of file
diff --git a/docs/locales/de/parsing/selection.md b/docs/locales/de/parsing/selection.md
new file mode 100644
index 0000000..7b7674d
--- /dev/null
+++ b/docs/locales/de/parsing/selection.md
@@ -0,0 +1,521 @@
+---
+title: "HTML-Daten mit CSS, XPath, Text und Regex auslesen"
+description: "Wählen Sie HTML-Elemente mit CSS, XPath, Text und Regex aus. Finden Sie ähnliche Elemente und lesen Sie Daten mit den Codebeispielen von Scrapling aus."
+---
+
+# Elemente auswählen {#querying-elements}
+Die Klasse `Selector` analysiert HTML. Dafür haben wir uns entschieden, weil die adaptive Funktion nicht mit XML funktioniert. Für XML-, RSS- oder Atom-Feeds nutzen Sie [XMLFeedSpider](../spiders/generic-templates.md#xmlfeedspider). Dieser verwendet einen XML-Parser und gibt Ihnen jeden Feed-Knoten direkt.
+
+In Scrapling gibt es fünf wichtige Wege, Elemente zu finden:
+
+1. CSS3-Selektoren
+2. XPath-Selektoren
+3. Suche mit Filtern oder Bedingungen
+4. Suche nach Elementen mit einem bestimmten Text
+5. Suche nach Elementen, deren Inhalt zu einer Regex passt
+
+Es gibt auch andere, indirekte Wege. Hier erklären wir die wichtigsten genauer. Außerdem zeigen wir eine besonders nützliche Funktion von Scrapling: Es kann Elemente finden, die einem bereits gefundenen Element ähneln. Sie können [direkt zu diesem Abschnitt springen](#finding-similar-elements).
+
+Wenn Sie neu im Web Scraping sind, kaum Erfahrung mit Selektoren haben und schnell anfangen möchten, empfehle ich Ihnen die Methoden `find`/`find_all`. Sie werden [hier erklärt](#filters-based-searching).
+
+## CSS/XPath-Selektoren {#cssxpath-selectors}
+
+### Was sind CSS-Selektoren? {#what-are-css-selectors}
+[CSS](https://en.wikipedia.org/wiki/CSS) ist eine Sprache zur Gestaltung von HTML-Dokumenten. Mit Selektoren ordnet sie die Gestaltung bestimmten HTML-Elementen zu.
+
+Scrapling unterstützt CSS3-Selektoren nach der [W3C-Spezifikation](http://www.w3.org/TR/2011/REC-css3-selectors-20110929/). Dafür nutzt es `cssselect`. Lesen Sie dort nach, welche [Selektoren](https://cssselect.readthedocs.io/en/latest/#supported-selectors), Pseudofunktionen und Pseudoelemente unterstützt werden.
+
+Scrapling bietet außerdem einige Pseudoelemente außerhalb des Standards:
+
+* Mit ``::text`` wählen Sie Textknoten aus.
+* Mit ``::attr(name)`` wählen Sie Attributwerte aus. Dabei steht name für den Namen des Attributs, dessen Wert Sie brauchen.
+
+Wenn Sie Scrapy oder Parsel kennen, finden Sie hier dieselbe Selektorlogik. So müssen Sie keine andere Arbeitsweise lernen :)
+
+Mit der Methode `css` wählen Sie Elemente über CSS-Selektoren aus. Sie gibt `Selectors` zurück. Mit `[0]` erhalten Sie das erste Element. Mit `.get()` / `.getall()` lesen Sie Textwerte aus Text- oder Attribut-Pseudoselektoren aus.
+
+### Was sind XPath-Selektoren? {#what-are-xpath-selectors}
+[XPath](https://en.wikipedia.org/wiki/XPath) ist eine Sprache zur Auswahl von Knoten in XML-Dokumenten. Sie lässt sich auch mit HTML nutzen. Diese [Kurzreferenz](https://devhints.io/xpath) hilft beim Lernen von [XPath](https://en.wikipedia.org/wiki/XPath). Scrapling stellt XPath-Selektoren direkt über [lxml](https://lxml.de/) bereit.
+
+Wie bei CSS finden Sie auch hier die bekannte Selektorlogik von Scrapy und Parsel. Scrapling bietet allerdings nicht deren XPath-Erweiterungsfunktion `has-class`. Stattdessen können Sie die Methode `has_class` für denselben Zweck auf gefundenen Elementen aufrufen.
+
+Für XPath-Selektoren verwenden Sie die Methode `xpath`. Sie folgt derselben Logik wie die oben gezeigte CSS-Methode.
+
+> Die Methoden `css` und `xpath` haben weitere Argumente für die adaptive Funktion. Diese erklären wir später ausführlich auf einer eigenen Seite.
+
+### Beispiele für Selektoren {#selectors-examples}
+Sehen wir uns einige Beispiele mit CSS und XPath an.
+
+Wählen Sie alle Elemente mit der Klasse `product` aus:
+```python
+products = page.css('.product')
+products = page.xpath('//*[@class="product"]')
+```
+!!! info "Hinweis:"
+
+ Der XPath-Ausdruck funktioniert nicht genau, wenn das Element noch eine weitere Klasse hat. **Für die Auswahl nach Klasse ist CSS immer die bessere Wahl.**
+
+Wählen Sie das erste Element mit der Klasse `product` aus:
+```python
+product = page.css('.product')[0]
+product = page.xpath('//*[@class="product"]')[0]
+```
+Lesen Sie den Text des ersten Elements mit dem Tag-Namen `h1` aus:
+```python
+title = page.css('h1::text').get()
+title = page.xpath('//h1//text()').get()
+```
+Das entspricht:
+```python
+title = page.css('h1')[0].text
+title = page.xpath('//h1')[0].text
+```
+Lesen Sie das Attribut `href` des ersten Elements mit dem Tag-Namen `a` aus:
+```python
+link = page.css('a::attr(href)').get()
+link = page.xpath('//a/@href').get()
+```
+Lesen Sie den Text des ersten `h1`-Elements aus, das `Phone` enthält und unter einem Element mit der Klasse `product` liegt:
+```python
+title = page.css('.product h1:contains("Phone")::text').get()
+title = page.xpath('//*[@class="product"]//h1[contains(text(),"Phone")]/text()').get()
+```
+Sie können Selektoren beliebig verschachteln und verketten, solange sie Ergebnisse liefern:
+```python
+page.css('.product')[0].css('h1:contains("Phone")::text').get()
+page.xpath('//*[@class="product"]')[0].xpath('.//h1[contains(text(),"Phone")]/text()').get()
+page.xpath('//*[@class="product"]')[0].css('h1:contains("Phone")::text').get()
+```
+Mit `.//` beginnt ein XPath relativ zum aktuellen Element. Ein führendes `//` durchsucht dagegen das ganze Dokument, auch nachdem Sie ein Produkt ausgewählt haben.
+
+Ein weiteres Beispiel:
+
+Alle Links, deren Attribut 'href' den Text 'image' enthält:
+```python
+links = page.css('a[href*="image"]')
+links = page.xpath('//a[contains(@href, "image")]')
+for index, link in enumerate(links):
+ link_value = link.attrib['href'] # Cleaner than link.css('::attr(href)').get()
+ link_text = link.text
+ print(f'Link number {index} points to this url {link_value} with text content as "{link_text}"')
+```
+
+## Nach Textinhalt auswählen {#text-content-selection}
+Scrapling kann Elemente über ihren direkten Textinhalt auswählen. Dafür gibt es zwei Wege:
+
+1. Mit `find_by_text` suchen Sie Elemente, deren direkter Text den angegebenen Text enthält. Mehrere Optionen steuern die Suche.
+2. Mit `find_by_regex` suchen Sie Elemente, deren direkter Text zum angegebenen Regex-Muster passt. Auch hier gibt es mehrere Optionen.
+
+Wenn Sie sich mit regulären Ausdrücken auskennen, können Sie alle Aufgaben von `find_by_text` auch mit `find_by_regex` lösen. Wir bieten beide Wege an, damit die Suche für alle einfach bleibt.
+
+Bei `find_by_text` ist das erste Argument der gesuchte Text. Bei `find_by_regex` ist es das Regex-Muster. Beide Methoden haben diese weiteren Argumente:
+
+* **first_match**: Bei `True`, dem Standardwert, gibt die Methode nur den ersten Treffer zurück.
+* **case_sensitive**: Bei `True` wird die Groß- und Kleinschreibung berücksichtigt.
+* **clean_match**: Bei `True` werden vor dem Vergleich alle Leerraumzeichen und aufeinanderfolgenden Leerzeichen durch ein einzelnes Leerzeichen ersetzt.
+
+Standardmäßig sucht `find_by_text` nach einer exakten Übereinstimmung. Der Text des gesuchten Elements darf dann nur aus dem angegebenen Text bestehen. Um das zu ändern, gibt es ein weiteres Argument:
+
+* **partial**: Wenn aktiviert, gibt `find_by_text` Elemente zurück, die den angegebenen Text enthalten. Der gesamte Text muss dann nicht genau übereinstimmen.
+
+!!! abstract "Hinweis:"
+
+ `find_by_regex` nimmt als erstes Argument eine normale Zeichenkette oder ein kompiliertes Regex-Muster an. Beispiele dazu folgen gleich.
+
+### Ähnliche Elemente finden {#finding-similar-elements}
+Eine besonders nützliche Funktion von Scrapling ist die Suche nach Elementen, die einem vorhandenen Element ähneln. Die Idee stammt aus AutoScraper. In Scrapling funktioniert sie aber mit Elementen, die Sie auf beliebige Weise gefunden haben. Oft wird sie nach einer Textsuche genutzt, wie bei AutoScraper. Deshalb erklären wir sie hier.
+
+Wie funktioniert das?
+
+Angenommen, Sie haben ein Produkt über seinen Titel gefunden und möchten die anderen Produkte aus derselben Tabelle oder demselben Container auslesen. Rufen Sie auf dem gefundenen Element `.find_similar()` auf. Scrapling führt dann diese Schritte aus:
+
+1. Es sucht alle Elemente auf derselben Ebene des DOM-Baums.
+2. Es prüft diese Elemente und entfernt alle, deren Tag-Name oder die Tag-Namen ihres Eltern- und Großelternelements nicht übereinstimmen.
+3. Nun sind die gewünschten Elemente mit etwa 99 % Sicherheit gefunden. Als letzte Prüfung vergleicht Scrapling ihre Attribute auf Ähnlichkeit. Elemente mit zu unähnlichen Attributen fallen weg. Ein Schwellenwert steuert diesen Schritt. Ändern Sie ihn am besten nur, wenn die Standardeinstellung nicht die gewünschten Ergebnisse liefert.
+
+Das war viel Erklärung, aber die Details sind wichtig. Im nächsten Abschnitt folgen Beispiele. Zuerst sehen wir uns die Argumente der Methode an:
+
+* **similarity_threshold**: Der Schwellenwert aus Schritt 3 zum Vergleich der Attribute. Der Standardwert ist 0,2. Die Attribute beider Elemente müssen also mindestens zu 20 % ähnlich sein. Mit 0 schalten Sie diese Prüfung und damit Schritt 3 aus. Lesen Sie aber zuerst die anderen Argumente durch.
+* **ignore_attributes**: Die hier angegebenen Attribute werden im letzten Vergleichsschritt ignoriert. Der Standardwert ist `('href', 'src',)`, weil URLs zwischen Elementen stark variieren und deshalb kein zuverlässiges Merkmal sind.
+* **match_text**: Bei `True` wird in Schritt 3 auch der Textinhalt verglichen. Für normale Fälle ist diese Option nicht empfohlen, sie kann aber je nach Aufgabe sinnvoll sein.
+
+Sehen wir uns nun die Beispiele an.
+
+### Beispiele {#examples}
+Hier sind einige Beispiele für die Suche mit Text und Regex.
+
+Die Beispiele nutzen `Fetcher`. Diese Klasse erklären wir später genauer.
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://books.toscrape.com/index.html')
+```
+Finden Sie das erste Element, dessen Text genau übereinstimmt:
+```python
+>>> page.find_by_text('Tipping the Velvet')
+<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>
+```
+Mit `page.urljoin` erhalten Sie aus dem relativen `href` die vollständige URL:
+```python
+>>> page.find_by_text('Tipping the Velvet').attrib['href']
+'catalogue/tipping-the-velvet_999/index.html'
+>>> page.urljoin(page.find_by_text('Tipping the Velvet').attrib['href'])
+'https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html'
+```
+Lesen Sie alle Treffer aus. Das Ergebnis ist eine Liste:
+```python
+>>> page.find_by_text('Tipping the Velvet', first_match=False)
+[<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>]
+```
+Finden Sie alle Elemente, die das Wort `the` enthalten, also teilweise übereinstimmen:
+```python
+>>> results = page.find_by_text('the', partial=True, first_match=False)
+>>> [i.text for i in results]
+['A Light in the ...',
+ 'Tipping the Velvet',
+ 'The Requiem Red',
+ 'The Dirty Little Secrets ...',
+ 'The Coming Woman: A ...',
+ 'The Boys in the ...',
+ 'The Black Maria',
+ 'Mesaerion: The Best Science ...',
+ "It's Only the Himalayas"]
+```
+Die Suche unterscheidet bisher nicht zwischen Groß- und Kleinschreibung. Deshalb sind Treffer mit `The` und nicht nur mit `the` dabei. Beschränken wir sie auf das kleingeschriebene `the`:
+```python
+>>> results = page.find_by_text('the', partial=True, first_match=False, case_sensitive=True)
+>>> [i.text for i in results]
+['A Light in the ...',
+ 'Tipping the Velvet',
+ 'The Boys in the ...',
+ "It's Only the Himalayas"]
+```
+Finden Sie das erste Element, dessen Text zu diesem Regex-Muster für Preise passt:
+```python
+>>> page.find_by_regex(r'£[\d\.]+')
+<data='<p class="price_color">£51.77</p>' parent='<div class="product_price"> <p class="pr...'>
+>>> page.find_by_regex(r'£[\d\.]+').text
+'£51.77'
+```
+Sie können auch eine kompilierte Regex übergeben. Scrapling erkennt den Typ und verarbeitet ihn entsprechend:
+```python
+>>> import re
+>>> regex = re.compile(r'£[\d\.]+')
+>>> page.find_by_regex(regex)
+<data='<p class="price_color">£51.77</p>' parent='<div class="product_price"> <p class="pr...'>
+>>> page.find_by_regex(regex).text
+'£51.77'
+```
+Lesen Sie alle Elemente aus, die zur Regex passen:
+```python
+>>> page.find_by_regex(r'£[\d\.]+', first_match=False)
+[<data='<p class="price_color">£51.77</p>' parent='<div class="product_price"> <p class="pr...'>,
+ <data='<p class="price_color">£53.74</p>' parent='<div class="product_price"> <p class="pr...'>,
+ <data='<p class="price_color">£50.10</p>' parent='<div class="product_price"> <p class="pr...'>,
+ <data='<p class="price_color">£47.82</p>' parent='<div class="product_price"> <p class="pr...'>,
+ ...]
+```
+Und so weiter...
+
+Finden Sie alle Elemente mit ähnlicher Position und ähnlichen Attributen. In diesem Fall ignorieren wir beim Vergleich das Attribut 'title':
+```python
+>>> element = page.find_by_text('Tipping the Velvet')
+>>> element.find_similar(ignore_attributes=['title'])
+[<data='<a href="catalogue/a-light-in-the-attic_...' parent='<h3><a href="catalogue/a-light-in-the-at...'>,
+ <data='<a href="catalogue/soumission_998/index....' parent='<h3><a href="catalogue/soumission_998/in...'>,
+ <data='<a href="catalogue/sharp-objects_997/ind...' parent='<h3><a href="catalogue/sharp-objects_997...'>,
+...]
+```
+Es sind 19 Elemente statt 20, weil das Ausgangselement nicht im Ergebnis enthalten ist.
+```python
+>>> len(element.find_similar(ignore_attributes=['title']))
+19
+```
+Lesen Sie das Attribut `href` aller ähnlichen Elemente aus:
+```python
+>>> [
+ element.attrib['href']
+ for element in element.find_similar(ignore_attributes=['title'])
+]
+['catalogue/a-light-in-the-attic_1000/index.html',
+ 'catalogue/soumission_998/index.html',
+ 'catalogue/sharp-objects_997/index.html',
+ ...]
+```
+Etwas umfangreicher wird es, wenn Sie alle Buchdaten auslesen möchten und dieses Element als Ausgangspunkt nutzen:
+```python
+>>> first_product = element.parent.parent
+>>> for product in [first_product, *first_product.find_similar()]:
+ print({
+ "name": product.css('h3 a::text').get(),
+ "price": product.css('.price_color')[0].re_first(r'[\d\.]+'),
+ "stock": product.css('.availability::text').getall()[-1].clean()
+ })
+{'name': 'Tipping the Velvet', 'price': '53.74', 'stock': 'In stock'}
+{'name': 'A Light in the ...', 'price': '51.77', 'stock': 'In stock'}
+{'name': 'Soumission', 'price': '50.10', 'stock': 'In stock'}
+{'name': 'Sharp Objects', 'price': '47.82', 'stock': 'In stock'}
+...
+```
+### Fortgeschrittene Beispiele {#advanced-examples}
+Hier sind weitere Beispiele für `find_similar`, die näher an typischen Aufgaben liegen.
+
+Produkte aus einem Onlineshop auslesen
+```python
+def extract_product_grid(page):
+ # Find the first product card
+ first_product = page.find_by_text('Add to Cart').find_ancestor(
+ lambda e: e.has_class('product-card')
+ )
+
+ # Find similar product cards
+ products = [first_product, *first_product.find_similar()]
+
+ return [
+ {
+ 'name': p.css('h3::text').get(),
+ 'price': p.css('.price::text').re_first(r'\d+\.\d{2}'),
+ 'stock': 'In stock' in p.get_all_text(),
+ 'rating': p.css('.rating')[0].attrib.get('data-rating')
+ }
+ for p in products
+ ]
+```
+Tabellenzeilen auslesen
+```python
+def extract_table_data(page):
+ # Find the first data row
+ first_row = page.css('table tbody tr')[0]
+
+ # Find similar rows
+ rows = [first_row, *first_row.find_similar()]
+
+ return [
+ {
+ 'column1': row.css('td:nth-child(1)::text').get(),
+ 'column2': row.css('td:nth-child(2)::text').get(),
+ 'column3': row.css('td:nth-child(3)::text').get()
+ }
+ for row in rows
+ ]
+```
+Formularfelder auslesen
+```python
+def extract_form_fields(page):
+ # Find first form field container
+ first_field = page.css('input')[0].find_ancestor(
+ lambda e: e.has_class('form-field')
+ )
+
+ # Find similar field containers
+ fields = [first_field, *first_field.find_similar()]
+
+ return [
+ {
+ 'label': f.css('label::text').get(),
+ 'type': f.css('input')[0].attrib.get('type'),
+ 'required': 'required' in f.css('input')[0].attrib
+ }
+ for f in fields
+ ]
+```
+Bewertungen von einer Website auslesen
+```python
+def extract_reviews(page):
+ # Find first review
+ first_review = page.find_by_text('Great product!')
+ review_container = first_review.find_ancestor(
+ lambda e: e.has_class('review')
+ )
+
+ # Find similar reviews
+ all_reviews = [review_container, *review_container.find_similar()]
+
+ return [
+ {
+ 'text': r.css('.review-text::text').get(),
+ 'rating': r.attrib.get('data-rating'),
+ 'author': r.css('.reviewer::text').get()
+ }
+ for r in all_reviews
+ ]
+```
+## Mit Filtern suchen {#filters-based-searching}
+Die Suche mit Filtern ist oft der beste Weg, Elemente in Scrapling zu finden. Sie ist leistungsfähig und für Einsteiger leichter zu lernen als Selektoren.
+
+Die Methoden `find_all` und `find` sind von der Funktion `find_all` aus BeautifulSoup inspiriert. Sie nehmen mehrere Filter an und suchen Elemente, die alle Bedingungen erfüllen.
+
+Dabei gilt:
+
+* Eine Zeichenkette wird als Tag-Name behandelt.
+* Ein iterierbares Objekt wie List, Tuple oder Set wird als Sammlung von Tag-Namen behandelt.
+* Ein Dictionary ordnet Attributnamen den gesuchten Werten von HTML-Elementen zu.
+* Regex-Muster filtern Elemente nach ihrem Inhalt, ähnlich wie `find_by_regex`.
+* Funktionen filtern die Elemente nach eigenen Bedingungen.
+* Jedes Schlüsselwortargument gilt als HTML-Attribut mit dem angegebenen Wert.
+
+Alle Argumente werden gesammelt. Die Filter werden nacheinander angewendet, wobei jeder Filter seine Ergebnisse an den nächsten weitergibt.
+
+Die Elemente der aktuellen Seite oder des aktuellen Elements werden in dieser Reihenfolge gefiltert:
+
+1. Alle Elemente mit den angegebenen Tag-Namen werden gesammelt.
+2. Die Elemente werden nach allen angegebenen Attributen gefiltert. Falls Schritt 1 ausgeführt wurde, wird nur dessen Ergebnis geprüft.
+3. Die Elemente werden nach allen angegebenen Regex-Mustern gefiltert. Falls zuvor Filter angewendet wurden, wird nur deren Ergebnis geprüft.
+4. Die Elemente werden nach allen angegebenen Funktionen gefiltert. Falls zuvor Filter angewendet wurden, wird nur deren Ergebnis geprüft.
+
+!!! note "Hinweise:"
+
+ 1. Die Verarbeitung beginnt mit dem ersten vorhandenen Filter in der oben genannten Reihenfolge. Wenn Sie keine Tag-Namen, aber Attribute angeben, startet sie also bei Schritt 2.
+ 2. Die Reihenfolge Ihrer Argumente spielt keine Rolle. Es gilt immer die oben beschriebene Reihenfolge.
+
+Die Beispiele machen es deutlicher :)
+
+### Beispiele {#examples_1}
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://quotes.toscrape.com/')
+```
+Finden Sie alle Elemente mit dem Tag-Namen `div`:
+```python
+>>> page.find_all('div')
+[<data='<div class="container"> <div class="row...' parent='<body> <div class="container"> <div clas...'>,
+ <data='<div class="row header-box"> <div class=...' parent='<div class="container"> <div class="row...'>,
+...]
+```
+Finden Sie alle div-Elemente, deren Klasse genau `quote` ist:
+```python
+>>> page.find_all('div', class_='quote')
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+...]
+```
+Dasselbe Ergebnis auf einem anderen Weg:
+```python
+>>> page.find_all('div', {'class': 'quote'})
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+...]
+```
+Finden Sie alle Elemente, deren Klasse genau `quote` ist:
+```python
+>>> page.find_all({'class': 'quote'})
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+...]
+```
+Finden Sie alle div-Elemente mit der Klasse `quote`, die ein Element `.text` mit dem Wort 'world' im Inhalt enthalten:
+```python
+>>> page.find_all('div', {'class': 'quote'}, lambda e: "world" in e.css('.text::text').get())
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>]
+```
+Finden Sie alle Elemente, die Kinder haben:
+```python
+>>> page.find_all(lambda element: len(element.children) > 0)
+[<data='<html lang="en"><head><meta charset="UTF...'>,
+ <data='<head><meta charset="UTF-8"><title>Quote...' parent='<html lang="en"><head><meta charset="UTF...'>,
+ <data='<body> <div class="container"> <div clas...' parent='<html lang="en"><head><meta charset="UTF...'>,
+...]
+```
+Finden Sie alle Elemente mit dem Wort 'world' im Inhalt:
+```python
+>>> page.find_all(lambda element: "world" in element.text)
+[<data='<span class="text" itemprop="text">“The...' parent='<div class="quote" itemscope itemtype="h...'>,
+ <data='<a class="tag" href="/tag/world/page/1/"...' parent='<div class="tags"> Tags: <meta class="ke...'>]
+```
+Finden Sie alle span-Elemente, die zur angegebenen Regex passen:
+```python
+>>> page.find_all('span', re.compile(r'world'))
+[<data='<span class="text" itemprop="text">“The...' parent='<div class="quote" itemscope itemtype="h...'>]
+```
+Finden Sie alle div- und span-Elemente mit der Klasse 'quote'. Hier gibt es keine passenden span-Elemente, daher werden nur div-Elemente zurückgegeben:
+```python
+>>> page.find_all(['div', 'span'], {'class': 'quote'})
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+...]
+```
+Kombinieren Sie verschiedene Filter:
+```python
+>>> page.find_all({'itemtype':"http://schema.org/CreativeWork"}, 'div').css('.author::text').getall()
+['Albert Einstein',
+ 'J.K. Rowling',
+...]
+```
+Noch ein Tipp: Finden Sie alle Elemente, deren `href`-Wert mit 'Einstein' endet:
+```python
+>>> page.find_all({'href$': 'Einstein'})
+[<data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,
+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,
+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>]
+```
+Ein weiterer Tipp: Finden Sie alle Elemente, deren `href`-Wert '/author/' enthält:
+```python
+>>> page.find_all({'href*': '/author/'})
+[<data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,
+ <data='<a href="/author/J-K-Rowling">(about)</a...' parent='<span>by <small class="author" itemprop=...'>,
+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,
+...]
+```
+Und so weiter...
+
+## Selektoren erzeugen {#generating-selectors}
+Sie können für jedes Element CSS- oder XPath-Selektoren erzeugen und diese in Scrapling oder anderswo wiederverwenden. Dabei spielt es keine Rolle, mit welcher Methode Sie das Element gefunden haben!
+
+Erzeugen Sie für `url_element` möglichst einen kurzen CSS-Selektor. Falls das nicht geht, wird ein vollständiger Selektor erzeugt:
+```python
+>>> url_element = page.find({'href*': '/author/'})
+>>> url_element.generate_css_selector
+'body > div > div:nth-of-type(2) > div > div > span:nth-of-type(2) > a'
+```
+Erzeugen Sie für `url_element` einen vollständigen CSS-Selektor vom Seitenanfang aus:
+```python
+>>> url_element.generate_full_css_selector
+'body > div > div:nth-of-type(2) > div > div > span:nth-of-type(2) > a'
+```
+Erzeugen Sie für `url_element` möglichst einen kurzen XPath-Selektor. Falls das nicht geht, wird ein vollständiger Selektor erzeugt:
+```python
+>>> url_element.generate_xpath_selector
+'//body/div/div[2]/div/div/span[2]/a'
+```
+Erzeugen Sie für `url_element` einen vollständigen XPath-Selektor vom Seitenanfang aus:
+```python
+>>> url_element.generate_full_xpath_selector
+'//body/div/div[2]/div/div/span[2]/a'
+```
+!!! abstract "Hinweis:"
+
+ Für einen kurzen Selektor sucht Scrapling ein eindeutig erkennbares Element als Ausgangspunkt, etwa eines mit einem `id`-Attribut. In unserem Fall gibt es keines. Deshalb sind der kurze und der vollständige Selektor gleich.
+
+## Selektoren mit regulären Ausdrücken nutzen {#using-selectors-with-regular-expressions}
+Wie in `parsel`/`scrapy` gibt es die Methoden `re` und `re_first`, um Daten mit regulären Ausdrücken auszulesen. In Scrapling stehen sie aber in fast allen Klassen bereit, etwa in `Selector`/`Selectors`/`TextHandler` und `TextHandlers`. Sie können sie daher direkt auf einem Element aufrufen, ohne zuvor einen Textknoten auszuwählen.
+
+Im Abschnitt zu [TextHandler](main_classes.md#texthandler) erklären wir das genauer. Grundsätzlich funktioniert es wie in diesen Beispielen:
+```python
+>>> page.css('.price_color')[0].re_first(r'[\d\.]+')
+'51.77'
+
+>>> page.css('.price_color').re_first(r'[\d\.]+')
+'51.77'
+
+>>> page.css('.price_color').re(r'[\d\.]+')
+['51.77',
+ '53.74',
+ '50.10',
+ '47.82',
+ '54.23',
+...]
+
+>>> page.css('.product_pod h3 a::attr(href)').re(r'catalogue/(.*)/index.html')
+['a-light-in-the-attic_1000',
+ 'tipping-the-velvet_999',
+ 'soumission_998',
+ 'sharp-objects_997',
+...]
+
+>>> filtering_function = lambda e: e.parent.tag == 'h3' and e.parent.parent.has_class('product_pod') # As above selector
+>>> page.find('a', filtering_function).attrib['href'].re(r'catalogue/(.*)/index.html')
+['a-light-in-the-attic_1000']
+
+>>> page.find_by_text('Tipping the Velvet').attrib['href'].re(r'catalogue/(.*)/index.html')
+['tipping-the-velvet_999']
+```
+Und so weiter. Auf der nächsten Seite erklären wir dies zusammen mit der Klasse [TextHandler](main_classes.md#texthandler) genauer.
\ No newline at end of file
diff --git a/docs/locales/de/spiders/advanced.md b/docs/locales/de/spiders/advanced.md
new file mode 100644
index 0000000..0340ff5
--- /dev/null
+++ b/docs/locales/de/spiders/advanced.md
@@ -0,0 +1,430 @@
+---
+title: "Crawls steuern: AutoThrottle, Checkpoints, Cache und Streaming"
+description: "Steuern Sie die Crawl-Geschwindigkeit und parallele Anfragen. Lernen Sie den Antwort-Cache, Pausieren und Fortsetzen, Datensatz-Streaming und den Inhalt von Checkpoints kennen."
+---
+
+# Erweiterte Funktionen {#advanced-usages}
+
+## Einführung {#introduction}
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Erste Schritte](getting-started.md) gelesen und wissen, wie Sie einen einfachen Spider erstellen und starten.
+
+Diese Seite erklärt die erweiterten Funktionen des Spider-Systems: parallele Anfragen steuern, pausieren und fortsetzen, Streaming, Lebenszyklus-Hooks, Statistiken und Protokollierung.
+
+## Parallele Anfragen steuern {#concurrency-control}
+
+Mit diesen Klassenattributen steuert das Spider-System, wie viele Anfragen es in welcher Zeit sendet:
+
+| Attribut | Standard | Beschreibung |
+|----------------------------------|----------|-------------------------------------------------------------------|
+| `concurrent_requests` | `4` | Höchste Anzahl gleichzeitig verarbeiteter Anfragen |
+| `concurrent_requests_per_domain` | `0` | Höchste Anzahl paralleler Anfragen pro Domain (0 = keine Grenze pro Domain) |
+| `download_delay` | `0.0` | Wartezeit vor jeder Anfrage in Sekunden |
+| `robots_txt_obey` | `False` | robots.txt-Regeln beachten (Disallow, Crawl-delay, Request-rate) |
+
+```python
+class PoliteSpider(Spider):
+ name = "polite"
+ start_urls = ["https://example.com"]
+
+ # Be gentle with the server
+ concurrent_requests = 4
+ concurrent_requests_per_domain = 2
+ download_delay = 1.0 # Wait 1 second between requests
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+Wenn `concurrent_requests_per_domain` gesetzt ist, erhält jede Domain neben der globalen Grenze eine eigene Grenze für parallele Anfragen. So können Sie mehrere Domains gleichzeitig abrufen und insgesamt viele Anfragen verarbeiten, ohne einzelne Domains zu stark zu belasten.
+
+!!! tip
+
+ Der Parameter `download_delay` fügt vor jeder Anfrage eine feste Wartezeit ein, unabhängig von der Domain. Damit begrenzen Sie die Anfragerate auf einfache Weise.
+
+## AutoThrottle {#autothrottle}
+
+Ein fester `download_delay` ist eine Schätzung. Ist er zu niedrig, werden Sie gesperrt. Ist er zu hoch, dauert der Crawl die ganze Nacht. AutoThrottle misst stattdessen, wie schnell die Website antwortet, und passt die Wartezeit für jede Domain an. Bei schnellen Servern geht es schneller, bei langsamen oder sperrenden Servern langsamer.
+
+| Attribut | Standard | Beschreibung |
+|------------------------------------|----------|--------------------------------------------------------------------|
+| `autothrottle_enabled` | `False` | Automatische Anpassung der Wartezeit einschalten |
+| `autothrottle_start_delay` | `5.0` | Wartezeit vor der ersten Anfrage an eine Domain |
+| `autothrottle_max_delay` | `60.0` | Höchste erlaubte Wartezeit |
+| `autothrottle_target_concurrency` | `None` | Angestrebte Anzahl paralleler Anfragen pro Domain, siehe unten |
+| `autothrottle_block_backoff` | `True` | Wartezeit einer Domain bei jeder Sperre verdoppeln |
+
+```python
+class AdaptiveSpider(Spider):
+ name = "adaptive"
+ start_urls = ["https://example.com"]
+
+ concurrent_requests = 8
+ concurrent_requests_per_domain = 1
+
+ autothrottle_enabled = True
+ autothrottle_start_delay = 2.0
+ autothrottle_max_delay = 30.0
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+Nach jeder Antwort nähert sich die Wartezeit der Antwortzeit des Servers an. Antwortet eine Website in 0,5 Sekunden, stellt sich eine Wartezeit von ungefähr 0,5 Sekunden ein. Das entspricht etwa einer laufenden Anfrage. Die Zielanzahl paralleler Anfragen pro Domain wird in dieser Reihenfolge bestimmt: `autothrottle_target_concurrency`, wenn gesetzt, sonst `concurrent_requests_per_domain`, sonst 1. Meist müssen Sie also keinen eigenen Zielwert setzen. Die bereits konfigurierte Grenze pro Domain wird verwendet und die Wartezeit durch diesen Wert geteilt. Steigt die Antwortzeit stark an, wirkt sich das sofort aus und wird nicht erst gemittelt. Der Spider wird daher sofort langsamer, wenn der Server Probleme hat, und beschleunigt nur schrittweise.
+
+### Bei Sperren langsamer werden {#backing-off-when-blocked}
+
+Die Antwortzeit allein erkennt keine Anfragelimits. Eine Antwort mit `429`, `403` oder einer CAPTCHA-Seite kommt oft *schneller* zurück als der eigentliche Inhalt. Nur nach Antwortzeit betrachtet wäre das ein Grund, schneller zu werden. Stattdessen **verdoppelt** jede fehlerhafte Antwort die Wartezeit der Domain. Dazu zählen Statuscodes außerhalb von 2xx und Antworten, die `is_blocked()` als gesperrt einstuft:
+
+```
+0.5s -> 1s -> 2s -> 4s -> 8s ... (up to autothrottle_max_delay)
+```
+
+Solange die Website Anfragen ablehnt, wird der Spider weiter langsamer. Sobald wieder erfolgreiche Antworten kommen, senkt die normale Mittelwertbildung die Wartezeit schrittweise auf die tatsächliche Antwortzeit. Der Spider erholt sich selbst, ohne dass Sie ihn neu starten müssen.
+
+Wenn die Website bei `429` oder `503` über den Header `Retry-After` eine genaue Wartezeit nennt, wird dieser Wert statt der Verdopplung verwendet. Sowohl die Zahlenform (`Retry-After: 120`) als auch das HTTP-Datumsformat werden unterstützt.
+
+Mit `autothrottle_block_backoff = False` schalten Sie dieses Verhalten aus. Dann wird nur die Antwortzeit berücksichtigt. Eine Sperre verhindert lediglich, dass der Spider schneller wird.
+
+Die endgültige Wartezeit pro Domain finden Sie in den Statistiken:
+
+```python
+result = AdaptiveSpider().start()
+print(result.stats.autothrottle_delays) # {'example.com': 0.62}
+```
+
+!!! note "Hinweise:"
+
+ * `download_delay` und Wartezeiten aus robots.txt bilden die Untergrenze. Doch auch diese wird durch `autothrottle_max_delay` begrenzt. Setzen Sie das Maximum mindestens so hoch wie die konfigurierte oder von robots.txt geforderte Wartezeit.<br/>
+ * `concurrent_requests_per_domain` hat zwei Aufgaben: Es begrenzt laufende Anfragen pro Domain und dient als Zielwert für AutoThrottle. Meist ist deshalb kein eigener Zielwert nötig. Wir empfehlen, diese Grenze zu setzen. Eine wartende Anfrage belegt nämlich einen Platz innerhalb der globalen Grenze. Ohne Grenze pro Domain können wartende Anfragen die Plätze belegen, die alle Domains gemeinsam nutzen.<br/>
+ * Die gemessene Antwortzeit umfasst den gesamten Abruf, einschließlich interner Wiederholungen und bei Browser-Sitzungen auch der Zeit zum Rendern der Seite.<br/>
+ * `autothrottle_max_delay` begrenzt alle Wartezeiten, auch `Retry-After`. Fordert eine Website eine längere Pause, erhöhen Sie `autothrottle_max_delay`, um sie einzuhalten.<br/>
+ * Die ermittelten Wartezeiten werden nicht in Checkpoints gespeichert. Nach dem Pausieren und Fortsetzen beginnt jede Domain wieder mit `autothrottle_start_delay`.
+
+## uvloop verwenden {#using-uvloop}
+
+Die Methode `start()` nimmt den Parameter `use_uvloop` an. Damit verwendet sie, falls verfügbar, die schnellere Event-Loop-Implementierung [uvloop](https://github.com/MagicStack/uvloop)/[winloop](https://github.com/nicktimko/winloop):
+
+```python
+result = MySpider().start(use_uvloop=True)
+```
+
+Das kann Crawls mit vielen Ein- und Ausgabevorgängen beschleunigen. Sie müssen `uvloop` unter Linux/macOS oder `winloop` unter Windows getrennt installieren.
+
+## Pausieren und fortsetzen {#pause-resume}
+
+Der Spider kann durch Checkpoints geordnet pausiert und fortgesetzt werden. Übergeben Sie dafür dem Konstruktor ein Verzeichnis als `crawldir`:
+
+```python
+spider = MySpider(crawldir="crawl_data/my_spider")
+result = spider.start()
+
+if result.paused:
+ print("Crawl was paused. Run again to resume.")
+else:
+ print("Crawl completed!")
+```
+
+### Funktionsweise {#how-it-works}
+
+1. **Pausieren:** Drücken Sie während des Crawls `Ctrl+C`. Der Spider wartet auf alle laufenden Anfragen, speichert offene Anfragen und Fingerprints bereits besuchter Anfragen in einem Checkpoint und beendet sich.
+2. **Sofort stoppen:** Drücken Sie `Ctrl+C` ein zweites Mal, um ohne Warten auf laufende Aufgaben zu stoppen.
+3. **Fortsetzen:** Starten Sie den Spider erneut mit demselben `crawldir`. Er erkennt den Checkpoint, stellt die Warteschlange und die Menge der bekannten Fingerprints wieder her und setzt den Crawl fort. Dabei wird `start_requests()` übersprungen.
+4. **Aufräumen:** Wird ein Crawl normal beendet und nicht pausiert, werden die Checkpoint-Dateien automatisch gelöscht.
+
+**Auch während des Crawls werden regelmäßig Checkpoints gespeichert, standardmäßig alle 5 Minuten.**
+
+So ändern Sie den Abstand:
+
+```python
+# Save checkpoint every 2 minutes
+spider = MySpider(crawldir="crawl_data/my_spider", interval=120.0)
+```
+
+Das Schreiben auf die Festplatte ist atomar und verhindert dadurch unvollständige Dateien.
+
+!!! tip
+
+ Bei `start()` wird der Spider durch `Ctrl+C` auch ohne aktiviertes Checkpoint-System geordnet beendet. Ein weiterer Tastendruck, bevor er fertig ist, beendet ihn sofort.
+
+### Erkennen, ob ein Crawl fortgesetzt wird {#knowing-if-youre-resuming}
+
+Der Hook `on_start()` erhält das Flag `resuming`:
+
+```python
+async def on_start(self, resuming: bool = False):
+ if resuming:
+ self.logger.info("Resuming from checkpoint!")
+ else:
+ self.logger.info("Starting fresh crawl")
+```
+
+## Entwicklungsmodus {#development-mode}
+
+Wenn Sie die `parse()`-Logik eines Spiders überarbeiten, sind neue Anfragen an die Zielserver bei jedem Lauf langsam und unnötig. Im Entwicklungsmodus werden alle Antworten beim ersten Lauf auf der Festplatte gespeichert und später von dort gelesen. So können Sie Ihre Selektoren ändern und den Spider beliebig oft neu starten, ohne diese Seiten erneut abzurufen.
+
+Setzen Sie dafür `development_mode = True` in Ihrem Spider:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ development_mode = True
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+Der erste Lauf ruft die Seiten normal ab und speichert jede Antwort auf der Festplatte. Bei späteren Läufen werden dieselben Anfragen aus dem Cache beantwortet. Der Seitenabruf entfällt. Bei `robots_txt_obey=True` werden die robots.txt-Regeln vor dem Lesen aus dem Cache geprüft.
+
+### Speicherort des Caches {#cache-location}
+
+Standardmäßig werden Antworten unter `.scrapling_cache/{spider.name}/` gespeichert. Der Pfad ist relativ zum aktuellen Arbeitsverzeichnis, also dort, wo Sie den Spider gestartet haben, **nicht** dort, wo das Spider-Skript liegt. Mit `development_cache_dir` ändern Sie den Speicherort:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ development_mode = True
+ development_cache_dir = "/tmp/my_spider_cache"
+```
+
+### Funktionsweise {#how-it-works_1}
+
+1. **Cache-Schlüssel:** Jede Antwort wird über den Fingerprint der Anfrage zugeordnet. Ändern Sie Attribute, die den Fingerprint beeinflussen (`fp_include_kwargs`, `fp_include_headers`, `fp_keep_fragments`), wird die Seite erneut abgerufen.
+2. **Speicherformat:** Pro Antwort wird eine JSON-Datei mit dem Namen `{fingerprint_hex}.json` erstellt. Der Body ist mit Base64 kodiert, damit Binärdaten exakt erhalten bleiben. Schreibvorgänge sind atomar: temporäre Datei und Umbenennen.
+3. **Wiederverwendung:** Bei einem Cache-Treffer überspringt die Engine den Seitenabruf samt `download_delay`, Begrenzung der Anfragerate und Wiederholungen über `is_blocked()`. Die gespeicherte Antwort geht direkt an Ihren Callback.
+4. **Statistiken:** Anfragen aus dem Cache zählen weiterhin für `requests_count`, `response_bytes` und die Zähler pro Statuscode. Die Statistik sieht also wie bei einem normalen Crawl aus. Die zusätzlichen Zähler `cache_hits` und `cache_misses` zeigen, wie oft der Cache eine Antwort liefern konnte.
+
+### Cache leeren {#clearing-the-cache}
+
+Cache-Einträge laufen nicht automatisch ab. Löschen Sie für einen neuen Crawl das Cache-Verzeichnis oder rufen Sie die Methode `clear()` des Managers direkt auf.
+
+!!! warning
+
+ Der Entwicklungsmodus ist nur für die Entwicklung gedacht. Gespeicherte Antworten laufen nie ab. Beim Lesen aus dem Cache werden Anfrageraten und Wiederholungen gesperrter Anfragen übersprungen. Setzen Sie einen Spider nicht mit `development_mode = True` im Produktivbetrieb ein.
+
+## Streaming {#streaming}
+
+Verwenden Sie `stream()` statt `start()` für lang laufende Spider oder Anwendungen, die sofort auf extrahierte Datensätze zugreifen müssen:
+
+```python
+import anyio
+
+async def main():
+ spider = MySpider()
+ async for item in spider.stream():
+ print(f"Got item: {item}")
+ # Access real-time stats
+ print(f"Items so far: {spider.stats.items_scraped}")
+ print(f"Requests made: {spider.stats.requests_count}")
+
+anyio.run(main)
+```
+
+Die wichtigsten Unterschiede zu `start()`:
+
+- `stream()` muss aus einem asynchronen Kontext aufgerufen werden.
+- Datensätze werden einzeln direkt nach der Extraktion geliefert, statt in einer Liste gesammelt zu werden.
+- Während des Durchlaufs erhalten Sie über `spider.stats` aktuelle Statistiken.
+
+!!! abstract
+
+ Alle über `spider.stats` verfügbaren Statistiken werden [weiter unten](#results-statistics) erklärt.
+
+Sie können Streaming auch mit Checkpoints verwenden. So lassen sich Oberflächen mit aktuellen Daten erstellen, in denen Crawls pausiert und fortgesetzt werden können.
+
+```python
+import anyio
+
+async def main():
+ spider = MySpider(crawldir="crawl_data/my_spider")
+ async for item in spider.stream():
+ print(f"Got item: {item}")
+ # Access real-time stats
+ print(f"Items so far: {spider.stats.items_scraped}")
+ print(f"Requests made: {spider.stats.requests_count}")
+
+anyio.run(main)
+```
+Mit `spider.pause()` können Sie den Spider im Beispiel auch aus dem Code heraus stoppen. Ohne aktiviertes Checkpoint-System wird der Crawl einfach beendet.
+
+## Lebenszyklus-Hooks {#lifecycle-hooks}
+
+Der Spider bietet mehrere Hooks, die Sie überschreiben können. Damit ergänzen Sie eigenes Verhalten in verschiedenen Phasen des Crawls:
+
+### on_start {#on_start}
+
+Wird vor Beginn des Crawls aufgerufen. Verwenden Sie ihn für Vorbereitungen, etwa das Laden von Daten oder Einrichten von Ressourcen:
+
+```python
+async def on_start(self, resuming: bool = False):
+ self.logger.info("Spider starting up")
+ # Load seed URLs from a database, initialize counters, etc.
+```
+
+### on_close {#on_close}
+
+Wird nach dem Crawl aufgerufen, unabhängig davon, ob dieser abgeschlossen oder pausiert wurde. Verwenden Sie ihn zum Aufräumen:
+
+```python
+async def on_close(self):
+ self.logger.info("Spider shutting down")
+ # Close database connections, flush buffers, etc.
+```
+
+### on_error {#on_error}
+
+Wird aufgerufen, wenn eine Anfrage mit einer Ausnahme fehlschlägt. Verwenden Sie ihn, um Fehler zu erfassen oder eine eigene Fehlerbehandlung einzubauen:
+
+```python
+async def on_error(self, request: Request, error: Exception):
+ self.logger.error(f"Failed: {request.url} - {error}")
+ # Log to error tracker, save failed URL for later, etc.
+```
+
+### on_scraped_item {#on_scraped_item}
+
+Wird für jeden extrahierten Datensatz aufgerufen, bevor er zu den Ergebnissen hinzugefügt wird. Geben Sie den Datensatz unverändert oder geändert zurück, um ihn zu behalten. Geben Sie `None` zurück, um ihn zu verwerfen:
+
+```python
+async def on_scraped_item(self, item: dict) -> dict | None:
+ # Drop items without a title
+ if not item.get("title"):
+ return None
+
+ # Modify items (e.g., add timestamps)
+ item["scraped_at"] = "2026-01-01"
+ return item
+```
+
+!!! tip
+
+ Mit diesem Hook können Sie Datensätze auch durch eigene Pipelines leiten und aus den Spider-Ergebnissen entfernen.
+
+### start_requests {#start_requests}
+
+Überschreiben Sie `start_requests()`, um die ersten Anfragen selbst zu erstellen, statt `start_urls` zu verwenden:
+
+```python
+async def start_requests(self):
+ # POST request to log in first
+ yield Request(
+ "https://example.com/login",
+ method="POST",
+ data={"user": "admin", "pass": "secret"},
+ callback=self.after_login,
+ )
+
+async def after_login(self, response: Response):
+ # Now crawl the authenticated pages
+ yield response.follow("/dashboard", callback=self.parse)
+```
+
+## Ergebnisse und Statistiken {#results-statistics}
+
+Das von `start()` zurückgegebene `CrawlResult` enthält sowohl die extrahierten Datensätze als auch ausführliche Statistiken:
+
+```python
+result = MySpider().start()
+
+# Items
+print(f"Total items: {len(result.items)}")
+result.items.to_json("output.json", indent=True)
+
+# Did the crawl complete?
+print(f"Completed: {result.completed}")
+print(f"Paused: {result.paused}")
+
+# Statistics
+stats = result.stats
+print(f"Requests: {stats.requests_count}")
+print(f"Failed: {stats.failed_requests_count}")
+print(f"Blocked: {stats.blocked_requests_count}")
+print(f"Offsite filtered: {stats.offsite_requests_count}")
+print(f"Robots.txt disallowed: {stats.robots_disallowed_count}")
+print(f"Cache hits: {stats.cache_hits}")
+print(f"Cache misses: {stats.cache_misses}")
+print(f"Items scraped: {stats.items_scraped}")
+print(f"Items dropped: {stats.items_dropped}")
+print(f"Response bytes: {stats.response_bytes}")
+print(f"Duration: {stats.elapsed_seconds:.1f}s")
+print(f"Speed: {stats.requests_per_second:.1f} req/s")
+```
+
+### Ausführliche Statistiken {#detailed-stats}
+
+Das Objekt `CrawlStats` erfasst detaillierte Angaben:
+
+```python
+stats = result.stats
+
+# Status code distribution
+print(stats.response_status_count)
+# {'status_200': 150, 'status_404': 3, 'status_403': 1}
+
+# Bytes downloaded per domain
+print(stats.domains_response_bytes)
+# {'example.com': 1234567, 'api.example.com': 45678}
+
+# Requests per session
+print(stats.sessions_requests_count)
+# {'http': 120, 'stealth': 34}
+
+# Proxies used during the crawl
+print(stats.proxies)
+# ['http://proxy1:8080', 'http://proxy2:8080']
+
+# Log level counts
+print(stats.log_levels_counter)
+# {'debug': 200, 'info': 50, 'warning': 3, 'error': 1, 'critical': 0}
+
+# Timing information
+print(stats.start_time) # Unix timestamp when crawl started
+print(stats.end_time) # Unix timestamp when crawl finished
+print(stats.download_delay) # The download delay used (seconds)
+
+# Concurrency settings used
+print(stats.concurrent_requests) # Global concurrency limit
+print(stats.concurrent_requests_per_domain) # Per-domain concurrency limit
+
+# AutoThrottle
+print(stats.autothrottle_enabled) # Whether the adaptive delay was on
+print(stats.autothrottle_delays) # Final delay per domain, {'example.com': 0.62}
+
+# Custom stats (set by your spider code)
+print(stats.custom_stats)
+# {'login_attempts': 3, 'pages_with_errors': 5}
+
+# Export everything as a dict
+print(stats.to_dict())
+```
+
+## Protokollierung {#logging}
+
+Der Spider hat einen eingebauten Logger, auf den Sie über `self.logger` zugreifen. Er verwendet bereits den Namen des Spiders und bietet diese Einstellungen:
+
+| Attribut | Standard | Beschreibung |
+|-----------------------|--------------------------------------------------------------|-----------------------------------------------------|
+| `logging_level` | `logging.DEBUG` | Niedrigste protokollierte Meldungsstufe |
+| `logging_format` | `"[%(asctime)s]:({spider_name}) %(levelname)s: %(message)s"` | Format der Protokollmeldungen |
+| `logging_date_format` | `"%Y-%m-%d %H:%M:%S"` | Datumsformat in Protokollmeldungen |
+| `log_file` | `None` | Pfad einer Protokolldatei zusätzlich zur Konsolenausgabe |
+
+```python
+import logging
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ logging_level = logging.INFO
+ log_file = "logs/my_spider.log"
+
+ async def parse(self, response: Response):
+ self.logger.info(f"Processing {response.url}")
+ yield {"title": response.css("title::text").get("")}
+```
+
+Das Verzeichnis der Protokolldatei wird bei Bedarf automatisch erstellt. Die Ausgabe in Konsole und Datei verwendet dasselbe Format.
diff --git a/docs/locales/de/spiders/architecture.md b/docs/locales/de/spiders/architecture.md
new file mode 100644
index 0000000..5551c80
--- /dev/null
+++ b/docs/locales/de/spiders/architecture.md
@@ -0,0 +1,107 @@
+---
+title: "So arbeiten die Webcrawler von Scrapling"
+description: "Erfahren Sie, wie Spider, Anfragen, Sitzungen, Scheduler und Crawler-Engine zusammenarbeiten. Vergleichen Sie den Ablauf mit Scrapy und wählen Sie Ihren Einstieg."
+---
+
+# Architektur der Spider {#spiders-architecture}
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Fetcher-Grundlagen](../fetching/choosing.md) gelesen und wissen, welche Fetcher es gibt und wann Sie diese verwenden.
+ 2. Sie haben die Seite [Hauptklassen](../parsing/main_classes.md) gelesen und kennen die Klassen [Selector](../parsing/main_classes.md#selector) und [Response](../fetching/choosing.md#response-object).
+
+Scraplings Spider-System ist ein von Scrapy inspiriertes Framework für asynchrone Crawls. Es unterstützt parallele Anfragen, mehrere Sitzungen sowie das Pausieren und Fortsetzen. Es verbindet Scraplings Parser und Fetcher in einer gemeinsamen Crawl-API und ergänzt die Planung von Anfragen, die Steuerung paralleler Abläufe und Checkpoints.
+
+Wenn Sie Scrapy kennen, finden Sie sich schnell zurecht. Falls nicht, ist das kein Problem. Das System ist einfach aufgebaut.
+
+## Datenfluss {#data-flow}
+
+Das Diagramm zeigt, wie Daten während eines Crawls durch das Spider-System fließen:
+
+<img src="../assets/spider_architecture.png" title="Diagramm der Spider-Architektur von @TrueSkills" alt="Diagramm der Spider-Architektur von @TrueSkills" style="width: 70%;"/>
+
+Beim Start eines Spiders läuft vereinfacht Folgendes ab:
+
+1. Der **Spider** erzeugt die ersten `Request`-Objekte. Standardmäßig erstellt er eine Anfrage für jede URL in `start_urls`. Für eigene Abläufe können Sie `start_requests()` überschreiben.
+2. Der **Scheduler** nimmt die Anfragen entgegen, legt sie in eine Prioritätswarteschlange und erstellt ihre Fingerprints. Anfragen mit höherer Priorität werden zuerst entnommen.
+3. Die **Crawler-Engine** fordert die nächste Anfrage beim **Scheduler** an. Dabei beachtet sie die globalen und domainspezifischen Grenzen für parallele Anfragen sowie die Wartezeiten. Wenn `robots_txt_obey` aktiv ist, prüft sie zuerst die robots.txt-Regeln der Domain. Nicht erlaubte Anfragen werden ohne Meldung verworfen. Die **Crawler-Engine** gibt die Anfrage dann an den **Session Manager** weiter. Dieser wählt anhand von `sid` (Sitzungs-ID) die passende Sitzung.
+4. Die **Sitzung** ruft die Seite ab und gibt ein [Response](../fetching/choosing.md#response-object)-Objekt an die **Crawler-Engine** zurück. Die Engine erfasst Statistiken und prüft, ob die Antwort auf eine Sperre hinweist. Bei einer Sperre versucht sie die Anfrage bis zu `max_blocked_retries` Mal erneut. Sie können sowohl die Erkennung als auch die Wiederholungslogik anpassen.
+5. Die **Crawler-Engine** übergibt die [Response](../fetching/choosing.md#response-object) an den Callback der Anfrage. Der Callback liefert entweder ein Dictionary, das als extrahierter Datensatz behandelt wird, oder eine Folgeanfrage, die der Scheduler in die Warteschlange aufnimmt.
+6. Der Ablauf wiederholt sich ab Schritt 2, bis der Scheduler leer ist und keine Aufgaben mehr laufen oder der Spider pausiert wird.
+7. Wenn beim Start des Spiders `crawldir` gesetzt ist, speichert die **Crawler-Engine** regelmäßig einen Checkpoint auf der Festplatte. Er enthält offene Anfragen und bereits besuchte URLs. Beim geordneten Beenden mit Strg+C wird ein letzter Checkpoint gespeichert. Beim nächsten Start mit demselben `crawldir` setzt der Spider dort fort. Er überspringt `start_requests()` und stellt den Zustand des Schedulers wieder her.
+
+
+## Komponenten {#components}
+
+### Spider {#spider}
+
+Die zentrale Klasse, mit der Sie arbeiten. Sie erstellen eine Unterklasse von `Spider` und legen `start_urls` sowie die Methode `parse()` fest. Bei Bedarf konfigurieren Sie Sitzungen und überschreiben Lebenszyklus-Hooks.
+
+```python
+from scrapling.spiders import Spider, Response, Request
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ async def parse(self, response: Response):
+ for link in response.css("a::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_page)
+
+ async def parse_page(self, response: Response):
+ yield {"title": response.css("h1::text").get("")}
+```
+
+### Crawler-Engine {#crawler-engine}
+
+Die Engine steuert den gesamten Crawl. Sie verwaltet die Hauptschleife, begrenzt parallele Anfragen, sendet Anfragen über den Session Manager und verarbeitet die Ergebnisse der Callbacks. Sie müssen sie nicht direkt aufrufen. Das übernehmen `Spider.start()` und `Spider.stream()` für Sie.
+
+### Scheduler {#scheduler}
+
+Eine Prioritätswarteschlange, die doppelte URLs automatisch erkennt. Die Fingerprints der Anfragen basieren auf URL, HTTP-Methode, Body und Sitzungs-ID. Mit `snapshot()` und `restore()` unterstützt der Scheduler das Checkpoint-System. So kann der Zustand des Crawls gespeichert und später wiederhergestellt werden.
+
+### Session Manager {#session-manager}
+
+Verwaltet eine oder mehrere benannte Sitzungen. Jede Sitzung hat einen dieser Typen:
+
+- [FetcherSession](../fetching/static.md)
+- [AsyncStealthySession](../fetching/stealthy.md)
+
+Der Session Manager leitet eingehende Anfragen anhand des Feldes `sid` an die richtige Sitzung weiter. Sitzungen starten entweder zusammen mit dem Spider (Standard) oder erst bei ihrer ersten Verwendung.
+
+### Checkpoint-System {#checkpoint-system}
+
+Ein optionales System, das den Zustand des Crawlers als pickle-Datei auf der Festplatte speichert. Dieser Zustand umfasst offene Anfragen und Fingerprints bereits besuchter URLs. Schreibvorgänge sind atomar (temporäre Datei und Umbenennen), damit Dateien nicht beschädigt werden. Checkpoints werden in einem einstellbaren Abstand und beim geordneten Beenden gespeichert. Nach einem erfolgreich abgeschlossenen Crawl, der nicht pausiert wurde, werden die Checkpoint-Dateien automatisch entfernt.
+
+### Antwort-Cache {#response-cache}
+
+Ein optionaler Cache, der im Entwicklungsmodus alle abgerufenen Antworten auf der Festplatte speichert und bei späteren Läufen wiederverwendet. Jede Antwort wird über den Fingerprint der Anfrage zugeordnet und als JSON gespeichert. Der Body wird mit Base64 kodiert, damit Binärdaten erhalten bleiben. Der Cache dient zum Überarbeiten der `parse()`-Logik, ohne die Zielserver erneut aufzurufen. Er ist nicht für den Produktivbetrieb gedacht.
+
+### Ausgabe {#output}
+
+Die extrahierten Datensätze werden in einer `ItemList` gesammelt. Diese Unterklasse von list bietet die Exportmethoden `to_json()`, `to_jsonl()`, `to_csv()` und `to_xml()`. Die Dataclass `CrawlStats` erfasst die Crawl-Statistiken und enthält viele nützliche Angaben.
+
+
+## Vergleich mit Scrapy {#comparison-with-scrapy}
+
+Wenn Sie von Scrapy kommen, hilft Ihnen diese Zuordnung:
+
+| Konzept | Scrapy | Scrapling |
+|----------------------|-------------------------------|-----------------------------------------------------------------|
+| Spider definieren | Unterklasse von `scrapy.Spider` | Unterklasse von `scrapling.spiders.Spider` |
+| Erste Anfragen | `start_requests()` | `async start_requests()` |
+| Callbacks | `def parse(self, response)` | `async def parse(self, response)` |
+| Links folgen | `response.follow(url)` | `response.follow(url)` |
+| Datensätze ausgeben | `yield dict` oder `yield Item` | `yield dict` |
+| Anfragen planen | Scheduler + Dupefilter | Scheduler mit eingebauter Erkennung doppelter Anfragen |
+| Herunterladen | Downloader + Middlewares | Session Manager mit Unterstützung für mehrere Sitzungen |
+| Datensätze verarbeiten | Item Pipelines | Hook `on_scraped_item()` |
+| Sperren erkennen | Eigene Middlewares | Eingebaute Hooks `is_blocked()` + `retry_blocked_request()` |
+| Parallele Anfragen | Einstellung `CONCURRENT_REQUESTS` | Klassenattribut `concurrent_requests` |
+| Domains filtern | `allowed_domains` | `allowed_domains` |
+| robots.txt | Einstellung `ROBOTSTXT_OBEY` | Klassenattribut `robots_txt_obey` |
+| Pausieren/Fortsetzen | Einstellung `JOBDIR` | Konstruktorargument `crawldir` |
+| Exportieren | Feed-Exporte | `result.items.to_json()` / `to_jsonl()` / `to_csv()` / `to_xml()` oder eigene Exporte über Hooks |
+| Starten | `scrapy crawl spider_name` | `MySpider().start()` |
+| Streaming | Nicht verfügbar | `async for item in spider.stream()` |
+| Mehrere Sitzungen | Nicht verfügbar | Mehrere Sitzungen verschiedener Typen pro Spider |
diff --git a/docs/locales/de/spiders/generic-templates.md b/docs/locales/de/spiders/generic-templates.md
new file mode 100644
index 0000000..7141091
--- /dev/null
+++ b/docs/locales/de/spiders/generic-templates.md
@@ -0,0 +1,278 @@
+---
+title: "Spider-Vorlagen für Links, Sitemaps, Feeds und Markdown"
+description: "Wählen Sie CrawlSpider, SitemapSpider, XMLFeedSpider, CSVFeedSpider oder ContentSpider. Legen Sie Regeln fest, um Seiten, Feed-Zeilen oder eine Markdown-Sammlung zu erfassen."
+---
+
+# Allgemeine Spider-Vorlagen {#generic-spider-templates}
+
+Die meisten Crawls folgen einem von zwei Mustern: „Links verfolgen, die zu diesem Muster passen“ oder „alle URLs aus der Sitemap abrufen“. Scrapling bietet Vorlagen für beide. So müssen Sie nicht jedes Mal denselben Grundaufbau für `parse()` schreiben.
+
+`CrawlSpider` und `SitemapSpider` bauen auf `LinkExtractor` auf. Dieser liest URLs aus einer `Response` oder prüft einzelne URLs mit `matches()`. `SitemapSpider` verarbeitet außerdem die Inhalte von sitemap.xml und sitemap_index.xml, mit oder ohne gzip-Komprimierung.
+
+Sie können `LinkExtractor` direkt in jeder normalen Methode `Spider.parse()` verwenden. Die Vorlagen nehmen Ihnen nur das Verknüpfen der Teile ab.
+
+## CrawlSpider {#crawlspider}
+
+`CrawlSpider` folgt Links automatisch anhand festgelegter Regeln.
+
+```python
+from scrapling.spiders import CrawlSpider, CrawlRule, LinkExtractor
+
+class QuotesSpider(CrawlSpider):
+ name = "blog"
+ start_urls = ["https://quotes.toscrape.com/"]
+
+ def rules(self):
+ return [
+ CrawlRule(LinkExtractor(allow=r"/author/"), callback=self.parse_author),
+ CrawlRule(LinkExtractor(allow=r"/page/\d+/")), # follow pagination, no callback
+ ]
+
+ async def parse_author(self, response):
+ yield {
+ '.author-title': response.css('.author-title::text').get(),
+ "birthday": response.css('.author-born-date::text').get(),
+ "url": response.url,
+ }
+
+result = QuotesSpider().start()
+```
+
+Eine `CrawlRule` verbindet einen `LinkExtractor` mit einem optionalen `callback`, einer gebundenen Methode des Spiders. Dazu kommen eine optionale `priority` für den erzeugten `Request` und ein optionales `process_request`. Letzteres ist eine gebundene Methode, die jeden `Request` vor der Ausgabe ändert. Die Standardmethode `parse()` wendet jede Regel auf jede Antwort an und liefert einen `Request` pro passender URL.
+
+Hat eine Regel keinen Callback, werden die passenden URLs an die Standardmethode `parse()` des Spiders weitergegeben. Das ist praktisch für Folgeseiten: Sie extrahieren die Links zur nächsten Seite und setzen den Crawl fort, ohne eine eigene Methode dafür zu brauchen.
+
+### Reihenfolge des Crawls {#crawl-order}
+
+Setzen Sie `crawl_strategy` auf `CrawlSpider` oder seinen Unterklassen, einschließlich `ContentSpider`, um die nächste offene Anfrage auszuwählen:
+
+| `crawl_strategy` | Reihenfolge bei gleicher `Request.priority` |
+|------------------|---------------------------------------------|
+| `"bfs"` (Standard) | Älteste Anfrage in der Warteschlange zuerst |
+| `"dfs"` | Neueste Anfrage in der Warteschlange zuerst |
+
+Der Scheduler nimmt offene Anfragen mit höherer `Request.priority` zuerst. Die Strategie legt nur die Reihenfolge bei gleicher Priorität fest.
+
+Mit `concurrent_requests = 1` wird jeweils eine Anfrage in der gewählten Reihenfolge verarbeitet. Doppelte URLs werden weiterhin gefiltert. Wird eine URL erneut gefunden, ändert sich die Position ihrer Anfrage nicht. Bei parallelen Anfragen können Seiten in anderer Reihenfolge fertig werden und sich Ebenen oder Zweige überschneiden.
+
+Behalten Sie beim Fortsetzen aus einem Checkpoint dieselbe `crawl_strategy` bei.
+
+### Regeln mit eigener Logik verbinden {#combining-rules-with-custom-logic}
+
+Überschreiben Sie `parse()` und rufen Sie `super().parse(response)` auf, um die Regeln zusammen mit Ihren eigenen Ausgaben zu verwenden:
+
+```python
+class MySpider(CrawlSpider):
+ def rules(self):
+ return [CrawlRule(LinkExtractor(allow=r"/posts/"), callback=self.parse_post)]
+
+ async def parse(self, response):
+ yield {"page_url": response.url}
+ async for req in super().parse(response):
+ yield req
+```
+
+### Anfragen mit `process_request` ändern {#mutating-requests-with-process_request}
+
+```python
+def add_priority(self, request, response):
+ request.priority = 10
+ return request
+
+def rules(self):
+ return [CrawlRule(
+ LinkExtractor(allow=r"/posts/"),
+ callback=self.parse_post,
+ process_request=self.add_priority,
+ )]
+```
+
+## SitemapSpider {#sitemapspider}
+
+`SitemapSpider` startet einen Crawl mit URLs aus sitemap.xml. Er verwendet dieselbe `rules()`-API wie `CrawlSpider`, sodass der Aufbau gleich bleibt.
+
+```python
+from scrapling.spiders import SitemapSpider, CrawlRule, LinkExtractor
+
+class MySitemap(SitemapSpider):
+ name = "sm"
+ sitemap_urls = ["https://example.com/sitemap.xml"]
+
+ def rules(self):
+ return [
+ CrawlRule(LinkExtractor(allow=r"/posts/"), callback=self.parse_post),
+ CrawlRule(LinkExtractor(allow=r"/products/"), callback=self.parse_product),
+ ]
+
+ async def parse_post(self, response):
+ yield {"title": response.css("h1::text").get()}
+
+ async def parse_product(self, response):
+ yield {"sku": response.css(".sku::text").get()}
+
+result = MySitemap().start()
+```
+
+### URLs zuordnen {#how-urls-are-dispatched}
+
+Für jede URL in der Sitemap prüft `SitemapSpider` nacheinander `LinkExtractor.matches(url)` jeder Regel. Die erste passende Regel gewinnt. Es wird ein `Request` mit dem Callback dieser Regel geliefert. Passt keine Regel und ist `rules()` nicht leer, wird die URL verworfen. Gibt `rules()` eine leere Liste zurück, wird jede URL an die Methode `parse()` des Spiders geleitet. Wenn Sie diese nicht überschreiben, löst sie standardmäßig `NotImplementedError` aus.
+
+### Sitemap-Indizes {#sitemap-indexes}
+
+Wenn `SitemapSpider` auf einen `<sitemapindex>` trifft, also eine Sitemap mit weiteren Sitemaps, folgt er diesen automatisch. Mit einem `LinkExtractor` in `sitemap_follow` filtern Sie, welchen untergeordneten Sitemaps er folgen soll:
+
+```python
+class MySitemap(SitemapSpider):
+ name = "sm"
+ sitemap_urls = ["https://example.com/sitemap.xml"]
+ sitemap_follow = LinkExtractor(allow=r"/posts-sitemap-\d+\.xml") # only post sitemaps
+```
+
+### Unterstützung für robots.txt {#robotstxt-support}
+
+Tragen Sie eine `robots.txt`-URL direkt in `sitemap_urls` ein. `SitemapSpider` erkennt sie, extrahiert alle angegebenen Sitemaps und folgt ihnen:
+
+```python
+class MySitemap(SitemapSpider):
+ name = "sm"
+ sitemap_urls = ["https://example.com/robots.txt"]
+```
+
+### URLs für andere Sprachen {#alternate-language-urls}
+
+Setzen Sie `sitemap_alternate_links = True`, um auch URLs aus `<xhtml:link rel="alternate" hreflang="...">` anhand Ihrer Regeln zu verarbeiten.
+
+## XMLFeedSpider {#xmlfeedspider}
+
+`XMLFeedSpider` durchläuft die Knoten eines XML-Feeds, etwa RSS, Atom oder Produktfeeds. Setzen Sie `itertag` auf den gewünschten Knotennamen, standardmäßig `"item"`. Überschreiben Sie `parse_node()`, das einmal pro passendem Knoten aufgerufen wird:
+
+```python
+from scrapling.spiders import XMLFeedSpider
+
+class RSSSpider(XMLFeedSpider):
+ name = "rss"
+ start_urls = ["https://example.com/feed.xml"]
+ itertag = "item"
+
+ async def parse_node(self, response, node):
+ yield {
+ "title": node.findtext("title"),
+ "link": node.findtext("link"),
+ "date": node.findtext("pubDate"),
+ }
+
+result = RSSSpider().start()
+```
+
+Wie die anderen Callbacks kann `parse_node()` auch `Request`-Objekte liefern, zum Beispiel `response.follow(node.findtext("link"), callback=self.parse_post)`. So ruft der Spider die Seiten auf, auf die der Feed verweist.
+
+### Knoten auswählen und verarbeiten {#how-nodes-are-matched-and-parsed}
+
+Jeder an `parse_node()` übergebene Knoten ist ein `lxml`-Element ohne Namespaces. Deshalb funktionieren `node.findtext("title")`, `node.find("thumbnail").get("url")` und `node.xpath(...)` mit jedem Feed ohne Namespace-Zuordnung. XPath unterscheidet dabei zwischen Groß- und Kleinschreibung. Ein einfaches `itertag` wie `"entry"` wählt Knoten nach ihrem Namen aus, unabhängig vom Namespace. Das passt für Atom und die meisten Feeds mit Namespaces. Für Knoten aus einem bestimmten Namespace verwenden Sie ein `itertag` mit Präfix und definieren dieses in `namespaces`:
+
+```python
+class ThumbnailSpider(XMLFeedSpider):
+ name = "thumbs"
+ start_urls = ["https://example.com/feed.xml"]
+ itertag = "media:thumbnail"
+ namespaces = (("media", "http://search.yahoo.com/mrss/"),)
+
+ async def parse_node(self, response, node):
+ yield {"thumbnail": node.get("url")}
+```
+
+Mit gzip komprimierte Feeds, etwa `.xml.gz` oder Inhalte mit einem gzip-Content-Type, werden automatisch entpackt. Dabei gelten dieselben Schutzmaßnahmen wie beim Sitemap-Spider. Fehlerhaftes XML führt zu einer Warnung im Protokoll, statt den Crawl abzubrechen.
+
+## CSVFeedSpider {#csvfeedspider}
+
+`CSVFeedSpider` durchläuft die Zeilen eines CSV-Feeds. Überschreiben Sie `parse_row()`. Die Methode erhält jede Zeile als Dictionary mit den Spaltennamen als Schlüsseln:
+
+```python
+from scrapling.spiders import CSVFeedSpider
+
+class PriceSpider(CSVFeedSpider):
+ name = "prices"
+ start_urls = ["https://example.com/products.csv"]
+
+ async def parse_row(self, response, row):
+ yield {"product": row["title"], "price": float(row["price"])}
+
+result = PriceSpider().start()
+```
+
+Standardmäßig dient die erste Zeile als Kopfzeile. Hat der Feed keine Kopfzeile, geben Sie die Spaltennamen selbst in `headers` an. Für Feeds, die nicht das übliche Kommaformat verwenden, stellen Sie `delimiter`/`quotechar` ein:
+
+```python
+class PriceSpider(CSVFeedSpider):
+ name = "prices"
+ start_urls = ["https://example.com/products.csv"]
+ headers = ["title", "price", "url"]
+ delimiter = ";"
+```
+
+Auch hier werden gzip-komprimierte Feeds automatisch entpackt, wie oben bei **XMLFeedSpider** beschrieben.
+
+<a id="sitetomarkdownspider"></a>
+
+## ContentSpider {#contentspider}
+
+`ContentSpider` baut auf **CrawlSpider** auf. Er durchsucht eine Website und wandelt jede Seite in bereinigtes Markdown für LLMs um. Er liefert einen Datensatz pro Seite und kann zusätzlich je Seite eine Markdown-Datei schreiben:
+
+```python
+from scrapling.spiders import ContentSpider
+
+class DocsSpider(ContentSpider):
+ name = "docs"
+ start_urls = ["https://example.com/docs/"]
+ allowed_domains = {"example.com"}
+ output_dir = "docs_markdown"
+
+result = DocsSpider().start()
+```
+
+Er benötigt `allowed_domains`, damit der Crawl auf die Zielwebsite begrenzt bleibt. Die vollständige Anleitung mit allen Optionen und der Weitergabe an RAG-Pipelines finden Sie unter [RAG-Systeme erstellen](../ai/building-rag-systems.md).
+
+## `LinkExtractor` direkt verwenden {#using-linkextractor-directly}
+
+Sie müssen die Vorlagen nicht verwenden. `LinkExtractor` funktioniert in jedem normalen `Spider`:
+
+```python
+from scrapling.spiders import Spider, LinkExtractor
+
+class CustomSpider(Spider):
+ name = "custom"
+ start_urls = ["https://example.com"]
+
+ def __init__(self):
+ super().__init__()
+ self._links = LinkExtractor(allow=r"/posts/", deny_domains="ads.example.com")
+
+ async def parse(self, response):
+ for url in self._links.extract(response):
+ yield response.follow(url, callback=self.parse_post)
+
+ async def parse_post(self, response):
+ yield {"title": response.css("h1::text").get()}
+```
+
+## LinkExtractor-Referenz {#linkextractor-reference}
+
+| Argument | Standard | Beschreibung |
+|-------------------|----------------------|----------------------------------------------------------------------------------------------------|
+| `allow` | `()` | Erlaubte URL-Muster. Leer bedeutet „alle“. String, kompiliertes `Pattern` oder Iterable aus beiden. |
+| `deny` | `()` | Zu verwerfende URL-Muster. Hat immer Vorrang vor `allow`. |
+| `allow_domains` | `()` | Erlaubte Hostnamen. Subdomains passen automatisch (`example.com` schließt `api.example.com` ein). |
+| `deny_domains` | `()` | Zu verwerfende Hostnamen. |
+| `restrict_css` | `()` | CSS-Selektoren, die die Extraktion aus dem DOM auf einen Bereich begrenzen. |
+| `restrict_xpath` | `()` | XPath-Selektoren, die die Extraktion aus dem DOM auf einen Bereich begrenzen. |
+| `tags` | `("a", "area")` | Element-Tags, in denen nach Links gesucht wird. |
+| `attrs` | `("href",)` | Attribute dieser Tags, aus denen URLs gelesen werden. |
+| `canonicalize` | `True` | Query-Parameter sortieren und den Pfad vereinheitlichen. |
+| `strip` | `True` | Leerraum am Anfang und Ende extrahierter URLs entfernen. |
+| `keep_fragment` | `False` | `#fragment` beim Vereinheitlichen beibehalten. |
+| `deny_extensions` | `IGNORED_EXTENSIONS` | Zu verwerfende Dateiendungen, etwa PDF, ZIP, Bilder und Videos. |
+| `process` | `None` | Optionale Funktion für jede extrahierte URL vor dem Filtern. Ein als falsch ausgewerteter Wert verwirft die URL. |
+
+`LinkExtractor.extract(response)` gibt eine `list[str]` mit absoluten, gefilterten URLs ohne Duplikate zurück.
+
+`LinkExtractor.matches(url)` gibt einen `bool` zurück. Die Methode filtert nur die URL nach erlaubten und ausgeschlossenen Mustern, Domain und Dateiendung. `SitemapSpider` verwendet sie, um URLs ohne `Response` zuzuordnen.
diff --git a/docs/locales/de/spiders/getting-started.md b/docs/locales/de/spiders/getting-started.md
new file mode 100644
index 0000000..eab8491
--- /dev/null
+++ b/docs/locales/de/spiders/getting-started.md
@@ -0,0 +1,199 @@
+---
+title: "Ihren ersten Python-Webcrawler mit Scrapling erstellen"
+description: "Erstellen Sie einen Spider, der Daten extrahiert, Folgeseiten aufruft und Ergebnisse exportiert. Lernen Sie Start-URLs, Callbacks, Domain-Grenzen und robots.txt-Einstellungen kennen."
+---
+
+# Erste Schritte {#getting-started}
+
+## Einführung {#introduction}
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Fetcher-Grundlagen](../fetching/choosing.md) gelesen und wissen, welche Fetcher es gibt und wann Sie diese verwenden.
+ 2. Sie haben die Seite [Hauptklassen](../parsing/main_classes.md) gelesen und kennen die Klassen [Selector](../parsing/main_classes.md#selector) und [Response](../fetching/choosing.md#response-object).
+ 3. Sie haben die Seite [Architektur](architecture.md) gelesen und wissen im Überblick, wie das Spider-System arbeitet.
+
+Mit dem Spider-System erstellen Sie in wenigen Codezeilen Crawler, die mehrere Seiten parallel abrufen. Wenn Sie Scrapy kennen, werden Ihnen die Abläufe vertraut sein. Falls nicht, erklärt diese Anleitung alles, was Sie für den Einstieg brauchen.
+
+## Ihr erster Spider {#your-first-spider}
+
+Ein Spider ist eine Klasse, die festlegt, wie Websites durchsucht und Daten daraus extrahiert werden. Hier ist ein möglichst einfacher Spider:
+
+```python
+from scrapling.spiders import Spider, Response
+
+class QuotesSpider(Spider):
+ name = "quotes"
+ start_urls = ["https://quotes.toscrape.com"]
+
+ async def parse(self, response: Response):
+ for quote in response.css("div.quote"):
+ yield {
+ "text": quote.css("span.text::text").get(""),
+ "author": quote.css("small.author::text").get(""),
+ }
+```
+
+Jeder Spider braucht drei Dinge:
+
+1. **`name`** - Eine eindeutige Kennung für den Spider.
+2. **`start_urls`** - Eine Liste der URLs, bei denen der Crawl beginnt.
+3. **`parse()`** - Eine asynchrone Generatormethode, die jede Antwort verarbeitet und Ergebnisse liefert.
+
+In der Methode `parse()` findet die Verarbeitung statt. Sie verwenden dieselben Auswahlmethoden wie bei Scraplings [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object) und geben die extrahierten Datensätze mit `yield` als Dictionaries aus.
+
+## Den Spider starten {#running-the-spider}
+
+Erstellen Sie eine Instanz und rufen Sie `start()` auf, um Ihren Spider zu starten:
+
+```python
+result = QuotesSpider().start()
+```
+
+Die Methode `start()` übernimmt die asynchrone Ausführung intern. Sie müssen sich also nicht um Event-Loops kümmern. Während der Spider läuft, werden alle Vorgänge im Terminal protokolliert. Am Ende des Crawls erhalten Sie ausführliche Statistiken.
+
+Diese Statistiken stehen im zurückgegebenen Objekt `CrawlResult`, das alle nötigen Ergebnisse enthält:
+
+```python
+result = QuotesSpider().start()
+
+# Access scraped items
+for item in result.items:
+ print(item["text"], "-", item["author"])
+
+# Check statistics
+print(f"Scraped {result.stats.items_scraped} items")
+print(f"Made {result.stats.requests_count} requests")
+print(f"Took {result.stats.elapsed_seconds:.1f} seconds")
+
+# Did the crawl finish or was it paused?
+print(f"Completed: {result.completed}")
+```
+
+## Links folgen {#following-links}
+
+Die meisten Crawls folgen Links über mehrere Seiten. Erstellen Sie mit `response.follow()` die Folgeanfragen:
+
+```python
+from scrapling.spiders import Spider, Response
+
+class QuotesSpider(Spider):
+ name = "quotes"
+ start_urls = ["https://quotes.toscrape.com"]
+
+ async def parse(self, response: Response):
+ # Extract items from the current page
+ for quote in response.css("div.quote"):
+ yield {
+ "text": quote.css("span.text::text").get(""),
+ "author": quote.css("small.author::text").get(""),
+ }
+
+ # Follow the "next page" link
+ next_page = response.css("li.next a::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page, callback=self.parse)
+```
+
+`response.follow()` verarbeitet relative URLs automatisch und verbindet sie mit der URL der aktuellen Seite. Standardmäßig setzt es diese Seite auch als Wert des Headers `Referer`.
+
+Für verschiedene Seitentypen können Sie Folgeanfragen an unterschiedliche Callback-Methoden senden:
+
+```python
+async def parse(self, response: Response):
+ for link in response.css("a.product-link::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_product)
+
+async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ }
+```
+
+!!! note
+
+ Alle Callback-Methoden müssen asynchrone Generatoren sein und `async def` sowie `yield` verwenden.
+
+## Daten exportieren {#exporting-data}
+
+Die in `result.items` zurückgegebene `ItemList` hat eingebaute Exportmethoden:
+
+```python
+result = QuotesSpider().start()
+
+# Export as JSON
+result.items.to_json("quotes.json")
+
+# Export as JSON with pretty-printing
+result.items.to_json("quotes.json", indent=True)
+
+# Export as JSON Lines (one JSON object per line)
+result.items.to_jsonl("quotes.jsonl")
+
+# Export as CSV or XML
+result.items.to_csv("quotes.csv")
+result.items.to_xml("quotes.xml")
+```
+
+Alle Methoden erstellen fehlende übergeordnete Verzeichnisse automatisch.
+
+`to_csv()` schreibt eine Spalte für jeden Schlüssel, der in Ihren Datensätzen vorkommt. Datensätze dürfen also unterschiedliche Schlüssel haben; fehlende Zellen bleiben leer. Mit `fields=[...]` wählen Sie die Spalten und ihre Reihenfolge selbst, mit `delimiter="\t"` erstellen Sie eine TSV-Datei. `to_xml()` umschließt jeden Datensatz mit einem `<item>`-Element innerhalb des Wurzelelements `<items>`. Beide Namen können Sie mit `root_tag` und `item_tag` ändern.
+
+In beiden Formaten werden Werte, die keine einfachen Skalare sind, etwa verschachtelte Dictionaries oder Listen, als JSON gespeichert. So gehen keine Daten unbemerkt verloren.
+
+## Domains filtern {#filtering-domains}
+
+Mit `allowed_domains` begrenzen Sie den Spider auf bestimmte Domains. So folgt er nicht versehentlich Links zu externen Websites:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ allowed_domains = {"example.com"}
+
+ async def parse(self, response: Response):
+ for link in response.css("a::attr(href)").getall():
+ # Links to other domains are silently dropped
+ yield response.follow(link, callback=self.parse)
+```
+
+Subdomains sind automatisch eingeschlossen. Mit `allowed_domains = {"example.com"}` erlauben Sie also auch `sub.example.com`, `blog.example.com` usw.
+
+Ausgefilterte Anfragen werden in `stats.offsite_requests_count` gezählt. So sehen Sie, wie viele verworfen wurden.
+
+## robots.txt beachten {#robotstxt-compliance}
+
+Setzen Sie `robots_txt_obey = True`, damit der Spider vor dem Abruf einer Domain deren robots.txt-Regeln beachtet:
+
+```python
+class PoliteSpider(Spider):
+ name = "polite"
+ start_urls = ["https://example.com"]
+ robots_txt_obey = True
+
+ async def parse(self, response: Response):
+ for link in response.css("a::attr(href)").getall():
+ yield response.follow(link, callback=self.parse)
+```
+
+Wenn diese Option aktiv ist, führt der Spider folgende Schritte aus:
+
+1. **robots.txt vorab abrufen:** Vor dem Crawl lädt er die Dateien für alle Domains in `start_urls` parallel.
+2. **Jede Anfrage prüfen:** Er prüft sie anhand der `Disallow`-Regeln in der robots.txt der Domain. Nicht erlaubte Anfragen werden ohne Meldung verworfen und in `stats.robots_disallowed_count` gezählt.
+3. **Die Vorgaben `Crawl-delay` und `Request-rate` beachten:** Er verwendet den höheren Wert aus der Vorgabe und Ihrem eingestellten `download_delay`. robots.txt kann Ihre Wartezeit somit nur erhöhen, niemals verkürzen. Wenn AutoThrottle aktiv ist, begrenzt dessen maximale Wartezeit auch diesen Wert. Setzen Sie `autothrottle_max_delay` hoch genug, um die geforderte Wartezeit einzuhalten.
+
+robots.txt-Dateien werden über die Standardsitzung des Spiders abgerufen und für den gesamten Crawl pro Domain zwischengespeichert. Für Domains, die erst während des Crawls gefunden werden und nicht in `start_urls` stehen, wird die Datei bei der ersten Anfrage an diese Domain abgerufen.
+
+**Hinweis:** `robots_txt_obey` ist standardmäßig ausgeschaltet, um unerwartetes Verhalten zu vermeiden. Wenn Sie es einschalten, bleiben Ihre Einstellungen für parallele Anfragen (`concurrent_requests`, `concurrent_requests_per_domain`) gleich. Nur die Wartezeit zwischen Anfragen wird angepasst.
+
+Wenn Sie `download_delay` nicht selbst wählen möchten, setzen Sie `autothrottle_enabled = True`. Der Spider passt dann die Wartezeit je Domain an deren Antwortgeschwindigkeit an und wartet bei Sperren länger. Siehe [AutoThrottle](advanced.md#autothrottle).
+
+## Nächste Schritte {#whats-next}
+
+Nachdem Sie die Grundlagen kennen, können Sie diese Themen ansehen:
+
+- [Anfragen und Antworten](requests-responses.md) - Prioritäten, Vermeidung doppelter Anfragen, Metadaten und mehr.
+- [Sitzungen](sessions.md) - Verschiedene Fetcher-Typen (HTTP, Browser, Stealth) in einem Spider verwenden.
+- [Proxys und Sperren](proxy-blocking.md) - Proxys zwischen Anfragen wechseln und Sperren behandeln.
+- [Erweiterte Funktionen](advanced.md) - Parallele Anfragen, AutoThrottle, Pausieren und Fortsetzen, Streaming, Lebenszyklus-Hooks und Protokollierung.
diff --git a/docs/locales/de/spiders/platform-templates.md b/docs/locales/de/spiders/platform-templates.md
new file mode 100644
index 0000000..8014c9d
--- /dev/null
+++ b/docs/locales/de/spiders/platform-templates.md
@@ -0,0 +1,59 @@
+---
+title: "Shopify-Produktdaten mit Python extrahieren"
+description: "Extrahieren Sie mit ShopifySpider den Katalog eines Shopify-Shops. Legen Sie die Shop-URL fest, erfassen Sie Produktvarianten und prüfen Sie die Felder der Datensätze."
+---
+
+# Spider-Vorlagen für Plattformen {#platform-spider-templates}
+
+Allgemeine Vorlagen decken Crawl-*Muster* ab, etwa Links folgen oder Sitemaps durchlaufen. Plattformvorlagen decken *Plattformen* ab: Systeme zum Erstellen von Websites, die auf vielen unabhängigen Websites dieselbe maschinenlesbare Struktur bereitstellen. Der Spider weiß dadurch bereits, wo die Daten liegen. Sie geben nur eine Domain an.
+
+## ShopifySpider {#shopifyspider}
+
+`ShopifySpider` extrahiert alle Produkte eines Shopify-Shops über die JSON-API von Shopify. Das HTML der Website wird dabei nicht verwendet.
+
+```python
+from scrapling.spiders import ShopifySpider
+
+class MyStore(ShopifySpider):
+ target_website = "example.com"
+
+result = MyStore().start()
+print(result.items[0])
+```
+
+Setzen Sie `target_website` auf die Domain des Shops. Ist der Wert leer, verwendet der Spider den ersten Eintrag in `start_urls`, danach in `allowed_domains`. Sind alle drei leer, löst er `ValueError` aus. Vollständige URLs werden automatisch auf ihre Domain gekürzt.
+
+### Funktionsweise {#how-it-works}
+
+1. Ruft die Seiten von `https://<store>/collections.json` ab, mit höchstens 250 Kollektionen pro Seite, dem Limit der Plattform.
+2. Ruft für jede Kollektion, die Produkte meldet, die Seiten von `/collections/<handle>/products.json` ab.
+3. Liefert einen Datensatz pro Produktvariante. Varianten aus mehreren Kollektionen werden nur einmal ausgegeben.
+
+### Felder der Datensätze {#item-fields}
+
+| Feld | Quelle |
+|---------------|---------------------------------------------------------------------------|
+| `name` | Produkttitel, ergänzt um den Variantentitel, wenn dieser nicht der Standardtitel ist |
+| `price` | Preis der Variante als String, genau wie von Shopify zurückgegeben |
+| `category` | Textkennung der Kollektion in der URL mit großem Anfangsbuchstaben je Wort (`summer-sale` wird zu `Summer Sale`) |
+| `brand` | Anbieter des Produkts |
+| `identifier` | ID der Variante |
+| `sku` | SKU der Variante oder `""`, wenn der Shop keine festlegt |
+| `stock` | `None`, wenn die Variante verfügbar ist, sonst `0` |
+| `image_url` | Erstes Produktbild oder `""` |
+| `url` | Produktseite innerhalb der Kollektion |
+| `description` | `body_html` des Produkts ohne HTML-Tags |
+| `old_price` | `compare_at_price`, wenn es ein tatsächlicher Preis vor dem Rabatt ist, sonst `""` |
+| `barcode` | Barcode der Variante oder `""` (die meisten Shops geben ihn an diesen Endpunkten nicht aus) |
+
+Diese Felder sind nicht vorgeschrieben. Überschreiben Sie `_process_product()` in Ihrer Unterklasse, um die Struktur der Datensätze zu ändern oder andere Felder aus den Produktdaten zu extrahieren.
+
+### Hinweise und Grenzen {#notes-and-limits}
+
+- Die JSON-Endpunkte zeigen nur Produkte, die im Onlineshop-Vertriebskanal veröffentlicht sind. Daher kann `products_count` einer Kollektion höher sein als die tatsächlich abrufbare Menge. Der Spider nutzt den Wert nur so: Ist er nicht null, wird die Kollektion abgerufen. Er dient nie als erwartete Gesamtzahl.
+- Bei Shops mit zusätzlichem Schutz oder Passwortschutz funktioniert diese Vorlage wahrscheinlich nicht. Wenn sie überhaupt funktioniert, müssen Sie viele Methoden selbst überschreiben.
+- Alle Funktionen von `Spider` gelten weiterhin: Einstellungen für parallele Anfragen, Wartezeiten, robots.txt, Checkpoints und Lebenszyklus-Hooks.
+
+### Welche Plattformvorlagen aufgenommen werden {#what-qualifies-as-a-platform-template}
+
+Wir nehmen Vorlagen für Plattformen auf, die wie Shopify auf vielen unabhängigen Websites eine einheitliche, maschinenlesbare Struktur bereitstellen. Spider für einzelne Websites gehören nicht in die Bibliothek, unabhängig davon, wie beliebt die Website ist.
diff --git a/docs/locales/de/spiders/proxy-blocking.md b/docs/locales/de/spiders/proxy-blocking.md
new file mode 100644
index 0000000..16444df
--- /dev/null
+++ b/docs/locales/de/spiders/proxy-blocking.md
@@ -0,0 +1,249 @@
+---
+title: "Proxys wechseln und gesperrte Crawl-Anfragen wiederholen"
+description: "Verwenden Sie Proxys und Wechselstrategien in Scrapling-Spidern. Erkennen Sie gesperrte Antworten, wiederholen Sie Anfragen und wechseln Sie von HTTP zu Browser-Sitzungen."
+---
+
+# Proxys verwalten und Sperren behandeln {#proxy-management-and-handling-blocks}
+
+## Einführung {#introduction}
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Erste Schritte](getting-started.md) gelesen und wissen, wie Sie einen einfachen Spider erstellen und starten.
+ 2. Sie haben die Seite [Sitzungen](sessions.md) gelesen und wissen, wie Sie Sitzungen konfigurieren.
+
+Beim Abruf großer Datenmengen müssen Sie oft zwischen mehreren Proxys wechseln, um Anfragelimits und Sperren zu vermeiden. Scraplings `ProxyRotator` macht das einfach. Er arbeitet mit allen Sitzungstypen und mit dem System des Spiders zum Wiederholen gesperrter Anfragen zusammen.
+
+Wenn Sie nicht wissen, was ein Proxy ist oder wie Sie einen guten auswählen, hilft Ihnen [diese Anleitung](https://substack.thewebscraping.club/p/everything-about-proxies).
+
+## ProxyRotator {#proxyrotator}
+
+Die Klasse `ProxyRotator` verwaltet eine Liste von Proxys und wechselt automatisch zwischen ihnen. Übergeben Sie sie mit dem Parameter `proxy_rotator` an einen beliebigen Sitzungstyp:
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession, ProxyRotator
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ def configure_sessions(self, manager):
+ rotator = ProxyRotator([
+ "http://proxy1:8080",
+ "http://proxy2:8080",
+ "http://user:pass@proxy3:8080",
+ ])
+ manager.add("default", FetcherSession(proxy_rotator=rotator))
+
+ async def parse(self, response: Response):
+ # Check which proxy was used
+ print(f"Proxy used: {response.meta.get('proxy')}")
+ yield {"title": response.css("title::text").get("")}
+```
+
+Jede Anfrage erhält automatisch den nächsten Proxy. Der verwendete Proxy wird in `response.meta["proxy"]` gespeichert. So sehen Sie, welcher Proxy welche Seite abgerufen hat.
+
+
+Für Browser-Sitzungen sind einige Anpassungen nötig:
+
+```python
+from scrapling.fetchers import AsyncStealthySession, ProxyRotator
+
+# String proxies work for all session types
+rotator = ProxyRotator([
+ "http://proxy1:8080",
+ "http://proxy2:8080",
+])
+
+# Dict proxies (Playwright format) work for browser sessions
+rotator = ProxyRotator([
+ {"server": "http://proxy1:8080", "username": "user", "password": "pass"},
+ {"server": "http://proxy2:8080"},
+])
+
+# Then inside the spider
+def configure_sessions(self, manager):
+ rotator = ProxyRotator(["http://proxy1:8080", "http://proxy2:8080"])
+ manager.add("browser", AsyncStealthySession(proxy_rotator=rotator))
+```
+
+!!! info
+
+ 1. Sie können `proxy_rotator` in derselben Sitzung nicht zusammen mit den festen Parametern `proxy` oder `proxies` verwenden. Wählen Sie beim Einrichten der Sitzung eine dieser Möglichkeiten. Später können Sie den Proxy für einzelne Anfragen überschreiben, wie unten gezeigt.
+ 2. Standardmäßig verwenden alle Browser-Sitzungen einen dauerhaften Browser-Kontext mit einem Pool aus Tabs. Browser können jedoch keinen eigenen Proxy pro Tab festlegen. Mit `ProxyRotator` öffnet der Fetcher deshalb automatisch für jeden Proxy einen eigenen Kontext mit einem Tab. Nach Abschluss der Aufgabe werden sowohl der Tab als auch sein Kontext geschlossen.
+
+## Eigene Wechselstrategien {#custom-rotation-strategies}
+
+Standardmäßig verwendet `ProxyRotator` einen zyklischen Wechsel: Er geht die Proxys der Reihe nach durch und beginnt am Ende wieder von vorn.
+
+Sie können eine eigene Strategiefunktion übergeben. Diese muss die folgende Signatur haben:
+
+```python
+from scrapling.core._types import ProxyType
+
+def my_strategy(proxies: list, current_index: int) -> tuple[ProxyType, int]:
+ ...
+```
+
+Sie erhält die Liste der Proxys und den aktuellen Index. Sie muss den ausgewählten Proxy und den nächsten Index zurückgeben.
+
+Hier sind einige Beispiele für eigene Wechselstrategien.
+
+### Zufälliger Wechsel {#random-rotation}
+
+```python
+import random
+from scrapling.fetchers import ProxyRotator
+
+def random_strategy(proxies, current_index):
+ idx = random.randint(0, len(proxies) - 1)
+ return proxies[idx], idx
+
+rotator = ProxyRotator(
+ ["http://proxy1:8080", "http://proxy2:8080", "http://proxy3:8080"],
+ strategy=random_strategy,
+)
+```
+
+### Gewichteter Wechsel {#weighted-rotation}
+
+```python
+import random
+
+def weighted_strategy(proxies, current_index):
+ # First proxy gets 60% of traffic, others split the rest
+ weights = [60] + [40 // (len(proxies) - 1)] * (len(proxies) - 1)
+ proxy = random.choices(proxies, weights=weights, k=1)[0]
+ return proxy, current_index # Index doesn't matter for weighted
+
+rotator = ProxyRotator(proxies, strategy=weighted_strategy)
+```
+
+
+## Proxy für einzelne Anfragen festlegen {#per-request-proxy-override}
+
+Mit dem Schlüsselwortargument `proxy=` überschreiben Sie den automatischen Wechsel für einzelne Anfragen:
+
+```python
+async def parse(self, response: Response):
+ # This request uses the rotator's next proxy
+ yield response.follow("/page1", callback=self.parse_page)
+
+ # This request uses a specific proxy, bypassing the rotator
+ yield response.follow(
+ "/special-page",
+ callback=self.parse_page,
+ proxy="http://special-proxy:8080",
+ )
+```
+
+Das ist nützlich, wenn bestimmte Seiten einen bestimmten Proxy brauchen, etwa einen Proxy aus einer bestimmten Region für regionale Inhalte.
+
+## Gesperrte Anfragen behandeln {#blocked-request-handling}
+
+Der Spider erkennt gesperrte Anfragen und wiederholt sie automatisch. Standardmäßig gelten diese HTTP-Statuscodes als Sperre: `401`, `403`, `407`, `429`, `444`, `500`, `502`, `503`, `504`.
+
+Die Wiederholungen laufen so ab:
+
+1. Nach Eingang einer Antwort ruft der Spider `is_blocked(response)` auf.
+2. Bei einer Sperre kopiert er die Anfrage und ruft `retry_blocked_request()` auf. So können Sie sie vor dem nächsten Versuch ändern.
+3. Die Anfrage kommt mit `dont_filter=True` und niedrigerer Priorität zurück in die Warteschlange. Dadurch wird sie nicht als doppelt verworfen und nicht sofort wiederholt.
+4. Das wird bis zu `max_blocked_retries` Mal wiederholt, standardmäßig 3 Mal.
+
+!!! tip
+
+ 1. Bei einem neuen Versuch werden die bisherigen Argumente `proxy`/`proxies` automatisch aus der Anfrage entfernt. So weist der Rotator einen neuen Proxy zu.
+ 2. Das Attribut `max_blocked_retries` ist von den Wiederholungen auf Sitzungsebene getrennt und verwendet einen eigenen Zähler.
+
+### Eigene Erkennung von Sperren {#custom-block-detection}
+
+Überschreiben Sie `is_blocked()`, um Ihre eigene Erkennung hinzuzufügen:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ async def is_blocked(self, response: Response) -> bool:
+ # Check status codes (default behavior)
+ if response.status in {403, 429, 503}:
+ return True
+
+ # Check response content
+ body = response.body.decode("utf-8", errors="ignore")
+ if "access denied" in body.lower() or "rate limit" in body.lower():
+ return True
+
+ return False
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+### Wiederholungen anpassen {#customizing-retries}
+
+Überschreiben Sie `retry_blocked_request()`, um die Anfrage vor dem nächsten Versuch zu ändern. Das Attribut `max_blocked_retries` bestimmt, wie oft eine gesperrte Anfrage wiederholt wird, standardmäßig 3 Mal:
+
+```python
+from scrapling.spiders import Spider, SessionManager, Request, Response
+from scrapling.fetchers import FetcherSession, AsyncStealthySession
+
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ max_blocked_retries = 5
+
+ def configure_sessions(self, manager: SessionManager) -> None:
+ manager.add('requests', FetcherSession(impersonate=['chrome', 'firefox', 'safari']))
+ manager.add('stealth', AsyncStealthySession(block_webrtc=True), lazy=True)
+
+ async def retry_blocked_request(self, request: Request, response: Response) -> Request:
+ request.sid = "stealth"
+ self.logger.info(f"Retrying blocked request: {request.url}")
+ return request
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+Im Beispiel bleibt die Erkennung von Sperren unverändert. Der Spider verwendet zunächst HTTP-Anfragen. Erst bei einer Sperre wechselt er zum Stealth-Browser.
+
+
+Alles zusammen:
+
+```python
+from scrapling.spiders import Spider, SessionManager, Request, Response
+from scrapling.fetchers import FetcherSession, AsyncStealthySession, ProxyRotator
+
+
+cheap_proxies = ProxyRotator([ "http://proxy1:8080", "http://proxy2:8080"])
+
+# A format acceptable by the browser
+expensive_proxies = ProxyRotator([
+ {"server": "http://residential_proxy1:8080", "username": "user", "password": "pass"},
+ {"server": "http://residential_proxy2:8080", "username": "user", "password": "pass"},
+ {"server": "http://mobile_proxy1:8080", "username": "user", "password": "pass"},
+ {"server": "http://mobile_proxy2:8080", "username": "user", "password": "pass"},
+])
+
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ max_blocked_retries = 5
+
+ def configure_sessions(self, manager: SessionManager) -> None:
+ manager.add('requests', FetcherSession(impersonate=['chrome', 'firefox', 'safari'], proxy_rotator=cheap_proxies))
+ manager.add('stealth', AsyncStealthySession(block_webrtc=True, proxy_rotator=expensive_proxies), lazy=True)
+
+ async def retry_blocked_request(self, request: Request, response: Response) -> Request:
+ request.sid = "stealth"
+ self.logger.info(f"Retrying blocked request: {request.url}")
+ return request
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+Die Logik im Beispiel: Anfragen verwenden günstige Proxys, etwa aus Rechenzentren, bis sie gesperrt werden. Danach werden sie mit höherwertigen Proxys wiederholt, etwa Residential- oder Mobilfunk-Proxys.
diff --git a/docs/locales/de/spiders/requests-responses.md b/docs/locales/de/spiders/requests-responses.md
new file mode 100644
index 0000000..85a1908
--- /dev/null
+++ b/docs/locales/de/spiders/requests-responses.md
@@ -0,0 +1,207 @@
+---
+title: "Spider-Anfragen, Callbacks und Response.follow"
+description: "Erstellen Sie Crawl-Anfragen, übergeben Sie Metadaten und folgen Sie Links mit response.follow. Lernen Sie Callbacks, Prioritäten und die Erkennung doppelter Anfragen kennen."
+---
+
+# Anfragen und Antworten {#requests-responses}
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Erste Schritte](getting-started.md) gelesen und wissen, wie Sie einen einfachen Spider erstellen und starten.
+
+Diese Seite erklärt das Objekt `Request` im Detail: Anfragen erstellen, Daten zwischen Callbacks übergeben, Prioritäten und doppelte Anfragen steuern sowie Links mit `response.follow()` folgen.
+
+## Das Request-Objekt {#the-request-object}
+
+Ein `Request` steht für eine abzurufende URL. Sie erstellen Anfragen entweder direkt oder mit `response.follow()`:
+
+```python
+from scrapling.spiders import Request
+
+# Direct construction
+request = Request(
+ "https://example.com/page",
+ callback=self.parse_page,
+ priority=5,
+)
+
+# Via response.follow (preferred in callbacks)
+request = response.follow("/page", callback=self.parse_page)
+```
+
+Sie können folgende Argumente an `Request` übergeben:
+
+| Argument | Typ | Standard | Beschreibung |
+|---------------|------------|------------|--------------------------------------------------------------------------------------------------------|
+| `url` | `str` | *erforderlich* | Die abzurufende URL |
+| `sid` | `str` | `""` | Sitzungs-ID, die die Anfrage an eine bestimmte Sitzung leitet (siehe [Sitzungen](sessions.md)) |
+| `callback` | `callable` | `None` | Asynchrone Generatormethode zum Verarbeiten der Antwort. Standardmäßig `parse()` |
+| `priority` | `int` | `0` | Höhere Werte werden zuerst verarbeitet |
+| `dont_filter` | `bool` | `False` | Wenn `True`, werden doppelte Anfragen zugelassen |
+| `meta` | `dict` | `{}` | Beliebige Metadaten, die an die Antwort weitergegeben werden |
+| `**kwargs` | | | Weitere Schlüsselwortargumente für die Abrufmethode der Sitzung, etwa `headers`, `method` und `data` |
+
+Alle zusätzlichen Schlüsselwortargumente werden direkt an die verwendete Sitzung weitergegeben. So erstellen Sie zum Beispiel eine POST-Anfrage:
+
+```python
+yield Request(
+ "https://example.com/api",
+ method="POST",
+ data={"key": "value"},
+ callback=self.parse_result,
+)
+```
+
+## Response.follow() {#responsefollow}
+
+Mit `response.follow()` erstellen Sie Folgeanfragen innerhalb von Callbacks. Das ist der empfohlene Weg und bietet gegenüber dem direkten Erstellen von `Request`-Objekten mehrere Vorteile:
+
+- **Relative URLs** werden automatisch anhand der URL der aktuellen Seite aufgelöst.
+- **Der Referer-Header** wird standardmäßig auf die URL der aktuellen Seite gesetzt.
+- **Sitzungsargumente** der ursprünglichen Anfrage werden übernommen, etwa Header und Proxy-Einstellungen. Ausgenommen sind `method`, `params`, `data`, `json`, `files` und `multipart`. Links werden daher mit einfachen GET-Anfragen abgerufen.
+- **Callback, Sitzungs-ID und Priorität** werden von der ursprünglichen Anfrage übernommen, wenn Sie keine neuen Werte angeben.
+
+```python
+async def parse(self, response: Response):
+ # Minimal - inherits callback, sid, priority from current request
+ yield response.follow("/next-page")
+
+ # Override specific fields
+ yield response.follow(
+ "/product/123",
+ callback=self.parse_product,
+ priority=10,
+ )
+
+ # Pass additional metadata to
+ yield response.follow(
+ "/details",
+ callback=self.parse_details,
+ meta={"category": "electronics"},
+ )
+```
+
+| Argument | Typ | Standard | Beschreibung |
+|--------------------|------------|------------|-------------------------------------------------------------|
+| `url` | `str` | *erforderlich* | Zu verfolgende URL, absolut oder relativ |
+| `sid` | `str` | `""` | Sitzungs-ID. Bei leerem Wert aus der ursprünglichen Anfrage übernommen |
+| `callback` | `callable` | `None` | Callback-Methode. Bei `None` aus der ursprünglichen Anfrage übernommen |
+| `priority` | `int` | `None` | Priorität. Bei `None` aus der ursprünglichen Anfrage übernommen |
+| `dont_filter` | `bool` | `False` | Doppelte Anfragen zulassen |
+| `meta` | `dict` | `None` | Metadaten, die mit denen der Antwort zusammengeführt werden |
+| **`referer_flow`** | `bool` | `True` | Aktuelle URL als Referer-Header setzen |
+| `**kwargs` | | | Werden mit den Sitzungsargumenten der ursprünglichen Anfrage zusammengeführt |
+
+### Referer-Weitergabe ausschalten {#disabling-referer-flow}
+
+Standardmäßig setzt `response.follow()` den Header `Referer` auf die URL der aktuellen Seite. So schalten Sie das aus:
+
+```python
+yield response.follow("/page", referer_flow=False)
+```
+
+## Callbacks {#callbacks}
+
+Callbacks sind asynchrone Generatormethoden Ihres Spiders, die Antworten verarbeiten. Sie müssen mit `yield` einen dieser drei Typen liefern:
+
+- **`dict`** - Ein extrahierter Datensatz, der zu den Ergebnissen hinzugefügt wird.
+- **`Request`** - Eine Folgeanfrage, die in die Warteschlange kommt.
+- **`None`** - Wird ohne Meldung ignoriert.
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ async def parse(self, response: Response):
+ # Yield items (dicts)
+ yield {"url": response.url, "title": response.css("title::text").get("")}
+
+ # Yield follow-up requests
+ for link in response.css("a::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_page)
+
+ async def parse_page(self, response: Response):
+ yield {"content": response.css("article::text").get("")}
+```
+
+!!! tip "Hinweis:"
+
+ Alle Callback-Methoden müssen mit `async def` definiert sein und `yield` statt `return` verwenden. Auch wenn ein Callback nur Datensätze und keine Folgeanfragen liefert, muss er ein asynchroner Generator sein.
+
+## Priorität von Anfragen {#request-priority}
+
+Anfragen mit höheren Prioritätswerten werden zuerst verarbeitet. Das ist nützlich, wenn Sie bestimmte Seiten vor anderen verarbeiten müssen:
+
+```python
+async def parse(self, response: Response):
+ # High priority - process product pages first
+ for link in response.css("a.product::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_product, priority=10)
+
+ # Low priority - pagination links processed after products
+ next_page = response.css("a.next::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page, callback=self.parse, priority=0)
+```
+
+Bei `response.follow()` wird die Priorität der ursprünglichen Anfrage übernommen, sofern Sie keinen neuen Wert angeben.
+
+## Doppelte Anfragen vermeiden {#deduplication}
+
+Der Spider erkennt doppelte Anfragen automatisch anhand eines Fingerprints aus URL, HTTP-Methode, Anfrage-Body und Sitzungs-ID. Erzeugen zwei Anfragen denselben Fingerprint, wird die zweite ohne Meldung verworfen.
+
+Mit `dont_filter=True` erlauben Sie doppelte Anfragen, etwa um eine Seite nach der Anmeldung erneut aufzurufen:
+
+```python
+yield Request("https://example.com/dashboard", dont_filter=True, callback=self.parse_dashboard)
+
+# Or with response.follow
+yield response.follow("/dashboard", dont_filter=True, callback=self.parse_dashboard)
+```
+
+Mit Klassenattributen Ihres Spiders steuern Sie genauer, was in den Fingerprint einfließt:
+
+| Attribut | Standard | Wirkung |
+|----------------------|----------|-----------------------------------------------------------------------------------------------------------------|
+| `fp_include_kwargs` | `False` | Zusätzliche Anfrageargumente aufnehmen, die Sie an die Abrufmethode der Sitzung übergeben haben, etwa Header |
+| `fp_keep_fragments` | `False` | URL-Fragmente (`#section`) bei der Berechnung des Fingerprints beibehalten |
+| `fp_include_headers` | `False` | Anfrage-Header in den Fingerprint aufnehmen |
+
+So behandeln Sie zum Beispiel `https://example.com/page#section1` und `https://example.com/page#section2` als unterschiedliche URLs:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ fp_keep_fragments = True
+ # ...
+```
+
+## Metadaten von Anfragen {#request-meta}
+
+Über das Dictionary `meta` übergeben Sie beliebige Daten zwischen Callbacks. Das ist nützlich, wenn Sie Angaben von einer Seite brauchen, um eine andere zu verarbeiten:
+
+```python
+async def parse(self, response: Response):
+ for product in response.css("div.product"):
+ category = product.css("span.category::text").get("")
+ link = product.css("a::attr(href)").get()
+ if link:
+ yield response.follow(
+ link,
+ callback=self.parse_product,
+ meta={"category": category},
+ )
+
+async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ # Access meta from the request
+ "category": response.meta.get("category", ""),
+ }
+```
+
+Bei `response.follow()` werden die Metadaten der aktuellen Antwort mit den neu übergebenen Metadaten zusammengeführt. Neue Werte haben Vorrang.
+
+Das Spider-System speichert auch einige Metadaten automatisch. Wenn die Proxy-Rotation aktiv ist, steht zum Beispiel der für eine Anfrage verwendete Proxy in `response.meta["proxy"]`.
diff --git a/docs/locales/de/spiders/sessions.md b/docs/locales/de/spiders/sessions.md
new file mode 100644
index 0000000..4d35915
--- /dev/null
+++ b/docs/locales/de/spiders/sessions.md
@@ -0,0 +1,231 @@
+---
+title: "HTTP- und Browser-Sitzungen in einem Crawler verwenden"
+description: "Richten Sie benannte Sitzungen ein und leiten Sie Spider-Anfragen über HTTP- oder Browser-Fetcher. Verwenden Sie Cookies erneut, starten Sie Sitzungen bei Bedarf und lesen Sie den API-Verlauf."
+---
+
+# Spider-Sitzungen {#spiders-sessions}
+
+!!! success "Voraussetzungen"
+
+ 1. Sie haben die Seite [Erste Schritte](getting-started.md) gelesen und wissen, wie Sie einen einfachen Spider erstellen und starten.
+ 2. Sie kennen die [Fetcher-Grundlagen](../fetching/choosing.md) und die Unterschiede zwischen HTTP- und Stealthy-Sitzungen.
+
+Ein Spider kann mehrere Fetcher-Sitzungen gleichzeitig verwenden. Zum Beispiel eine schnelle HTTP-Sitzung für einfache Seiten und einen Stealth-Browser für geschützte Seiten. Diese Seite zeigt, wie Sie Sitzungen einrichten und verwenden.
+
+## Was sind Sitzungen? {#what-are-sessions}
+
+Eine Sitzung ist eine vorkonfigurierte Fetcher-Instanz, die während des gesamten Crawls aktiv bleibt. Statt für jede Anfrage eine neue Verbindung oder einen neuen Browser zu erstellen, verwendet der Spider die Sitzungen erneut. Das ist schneller und braucht weniger Ressourcen.
+
+Standardmäßig erstellt jeder Spider eine [FetcherSession](../fetching/static.md). Überschreiben Sie `configure_sessions()`, um weitere Sitzungen hinzuzufügen oder die Standardsitzung zu ersetzen. Sie dürfen dabei nur die asynchrone Variante der jeweiligen Sitzung verwenden, wie die Tabelle zeigt:
+
+
+| Sitzungstyp | Einsatzzweck |
+|-------------------------------------------------|------------------------------------------|
+| [FetcherSession](../fetching/static.md) | Schnelle HTTP-Anfragen ohne JavaScript |
+| [AsyncStealthySession](../fetching/stealthy.md) | JavaScript, Browser-Automatisierung, Umgehen von Bot-Schutz |
+
+
+## Sitzungen konfigurieren {#configuring-sessions}
+
+Überschreiben Sie `configure_sessions()` in Ihrem Spider, um Sitzungen einzurichten. Der Parameter `manager` ist eine Instanz von `SessionManager`. Registrieren Sie Sitzungen mit `manager.add()`:
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ def configure_sessions(self, manager):
+ manager.add("default", FetcherSession())
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+Die Methode `manager.add()` nimmt diese Argumente an:
+
+| Argument | Typ | Standard | Beschreibung |
+|--------------|-----------|----------------|-----------------------------------------------|
+| `session_id` | `str` | *erforderlich* | Name, mit dem Anfragen diese Sitzung auswählen |
+| `session` | `Session` | *erforderlich* | Die Sitzungsinstanz |
+| `default` | `bool` | `False` | Diese Sitzung als Standardsitzung festlegen |
+| `lazy` | `bool` | `False` | Sitzung erst bei der ersten Verwendung starten |
+
+!!! note "Hinweise:"
+
+ 1. Wenn Sie in einer Anfrage keine Sitzung angeben, wird die Standardsitzung verwendet. Sie wird auf eine von zwei Arten festgelegt:
+ 1. Die erste hinzugefügte Sitzung wird automatisch zur Standardsitzung.
+ 2. Beim Hinzufügen einer Sitzung setzen Sie `default=True`.
+ 2. Sie müssen die übergebenen Sitzungsinstanzen nicht selbst starten. Der Spider prüft alle Sitzungen und startet die, die noch nicht laufen.
+ 3. Mit dem Argument `lazy` beim Hinzufügen startet eine Sitzung erst bei Bedarf. So startet zum Beispiel der Browser erst, wenn er gebraucht wird, und nicht gleich mit dem Spider.
+
+## Spider mit mehreren Sitzungen {#multi-session-spider}
+
+Ein praktisches Beispiel: Verwenden Sie eine schnelle HTTP-Sitzung für Übersichtsseiten und einen Stealth-Browser für Detailseiten mit Bot-Schutz:
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession, AsyncStealthySession
+
+class ProductSpider(Spider):
+ name = "products"
+ start_urls = ["https://shop.example.com/products"]
+
+ def configure_sessions(self, manager):
+ # Fast HTTP for listing pages (default)
+ manager.add("http", FetcherSession())
+
+ self.browser_session = AsyncStealthySession(
+ headless=True,
+ network_idle=True,
+ record_requests=True,
+ )
+ manager.add("stealth", self.browser_session)
+
+ async def parse(self, response: Response):
+ for link in response.css("a.product::attr(href)").getall():
+ # Route product pages through the stealth session
+ yield response.follow(link, sid="stealth", callback=self.parse_product)
+
+ next_page = response.css("a.next::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page)
+
+ async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ }
+
+ async def on_close(self):
+ for api_response in self.browser_session.network.search(
+ url_pattern=r"https://api\.shop\.example\.com/.*", limit=None
+ ):
+ self.logger.info(f"Saved API response: {api_response.url} ({api_response.status})")
+```
+
+Das Beispiel behält die Browser-Instanz und liest den gespeicherten API-Verlauf einmal in `on_close()`, bevor die Sitzungen geschlossen werden. Der Verlauf enthält alle Produktseiten und bleibt auch nach dem Schließen lesbar. Noch laufende Aufzeichnungen werden nicht abgewartet. Die Speichergrenzen gelten weiterhin.
+
+Entscheidend ist der Parameter `sid`. Er sagt dem Spider, welche Sitzung er für die jeweilige Anfrage verwenden soll. Wenn Sie `response.follow()` ohne `sid` aufrufen, wird die Sitzungs-ID der ursprünglichen Anfrage übernommen.
+
+Sitzungen müssen nicht aus unterschiedlichen Klassen stammen. Sie können auch mehrere Instanzen derselben Klasse mit verschiedenen Einstellungen verwenden:
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession
+
+class ProductSpider(Spider):
+ name = "products"
+ start_urls = ["https://shop.example.com/products"]
+
+ def configure_sessions(self, manager):
+ chrome_requests = FetcherSession(impersonate="chrome")
+ firefox_requests = FetcherSession(impersonate="firefox")
+
+ manager.add("chrome", chrome_requests)
+ manager.add("firefox", firefox_requests)
+
+ async def parse(self, response: Response):
+ for link in response.css("a.product::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_product)
+
+ next_page = response.css("a.next::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page, sid="firefox")
+
+ async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ }
+```
+
+Sie können auch eine eigene Sitzung mit ihren Cookies und ihrem Zustand für bestimmte Anfragen behalten.
+
+## Sitzungsargumente {#session-arguments}
+
+Zusätzliche Schlüsselwortargumente an `Request` oder über `response.follow(**kwargs)` werden an die Abrufmethode der Sitzung weitergegeben. So passen Sie einzelne Anfragen an, ohne die Sitzungskonfiguration zu ändern:
+
+```python
+async def parse(self, response: Response):
+ # Pass extra headers for this specific request
+ yield Request(
+ "https://api.example.com/data",
+ headers={"Authorization": "Bearer token123"},
+ callback=self.parse_api,
+ )
+
+ # Use a different HTTP method
+ yield Request(
+ "https://example.com/submit",
+ method="POST",
+ data={"field": "value"},
+ sid="firefox",
+ callback=self.parse_result,
+ )
+```
+
+!!! warning
+
+ Normalerweise wählen Sie bei `FetcherSession`, `Fetcher` oder `AsyncFetcher` die HTTP-Methode durch den Aufruf von `.get()` oder `.post()`. Bei `FetcherSession` innerhalb von Spidern geht das nicht. Standardmäßig wird eine _HTTP-GET_-Anfrage gesendet. Für eine andere HTTP-Methode müssen Sie das Argument `method` übergeben, wie im Beispiel oben. Dadurch bleibt die Schnittstelle von `Request` für alle Sitzungstypen gleich.
+
+Mit der Sitzung `"stealth"` (`AsyncStealthySession`) aus dem Beispiel oben können Sie browserspezifische Argumente wie `wait_selector`, `page_action` oder `extra_headers` übergeben:
+
+```python
+async def parse(self, response: Response):
+ # Use Cloudflare solver with the `AsyncStealthySession` we configured above
+ yield Request(
+ "https://nopecha.com/demo/cloudflare",
+ sid="stealth",
+ callback=self.parse_result,
+ solve_cloudflare=True,
+ block_webrtc=True,
+ hide_canvas=True,
+ google_search=True,
+ )
+
+ yield response.follow(
+ "/dynamic-page",
+ sid="stealth",
+ callback=self.parse_dynamic,
+ wait_selector="div.loaded",
+ network_idle=True,
+ )
+```
+
+!!! warning
+
+ `response.follow()` übernimmt die Sitzungsargumente (**kwargs) der ursprünglichen Anfrage, außer `method`, `params`, `data`, `json`, `files` und `multipart`. Nach einer POST-Anfrage wird ein Link daher mit einem einfachen GET abgerufen. Neue Argumente haben Vorrang vor übernommenen Werten.
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession
+
+class ProductSpider(Spider):
+ name = "products"
+ start_urls = ["https://shop.example.com/products"]
+
+ def configure_sessions(self, manager):
+ manager.add("http", FetcherSession(impersonate='chrome'))
+
+ async def parse(self, response: Response):
+ # I don't want the follow request to impersonate a desktop Chrome like the previous request, but a mobile one
+ # so I override it like this
+ for link in response.css("a.product::attr(href)").getall():
+ yield response.follow(link, impersonate="chrome131_android", callback=self.parse_product)
+
+ next_page = response.css("a.next::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page)
+
+ async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ }
+```
+!!! info
+
+ Beim Beenden des Spiders prüft der Manager automatisch, ob noch Sitzungen laufen, und schließt sie, bevor der Spider beendet wird.
diff --git a/docs/locales/de/stylesheets b/docs/locales/de/stylesheets
new file mode 120000
index 0000000..02c6ba6
--- /dev/null
+++ b/docs/locales/de/stylesheets
@@ -0,0 +1 @@
+../../stylesheets
\ No newline at end of file
diff --git a/docs/locales/de/tutorials/migrating_from_beautifulsoup.md b/docs/locales/de/tutorials/migrating_from_beautifulsoup.md
new file mode 100644
index 0000000..6edbe83
--- /dev/null
+++ b/docs/locales/de/tutorials/migrating_from_beautifulsoup.md
@@ -0,0 +1,99 @@
+---
+title: "Von BeautifulSoup zu Scrapling wechseln"
+description: "Vergleichen Sie häufige Aufgaben mit BeautifulSoup und Scrapling: Auswahl, Text, Attribute und Navigation. Lernen Sie die API-Unterschiede anhand praktischer Beispiele kennen."
+---
+
+# Von BeautifulSoup zu Scrapling wechseln {#migrating-from-beautifulsoup-to-scrapling}
+
+Wenn Sie BeautifulSoup bereits kennen, wird Ihnen der Einstieg leichtfallen. Scrapling ist deutlich schneller, bietet dieselben Parsing-Funktionen und fügt weitere hinzu. Dazu kommen Funktionen zum Abrufen und Verarbeiten moderner Webseiten. Diese Anleitung hilft Ihnen, Ihren bestehenden BeautifulSoup-Code schnell an Scrapling anzupassen.
+
+Die folgende Tabelle zeigt die häufigsten Aufgaben beim Web Scraping. Jede Zeile nennt den Code für BeautifulSoup und die entsprechende Methode in Scrapling.
+
+Einige Abkürzungen von BeautifulSoup fehlen in Scrapling. Das ist einer der Gründe, warum BeautifulSoup langsamer ist. Wenn sich eine Funktion schon mit einer kurzen Zeile nutzen lässt, müssen wir diese nicht auf Kosten der Geschwindigkeit noch kürzer machen :)
+
+| Aufgabe | BeautifulSoup-Code | Scrapling-Code |
+|-----------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------|
+| Parser importieren | `from bs4 import BeautifulSoup` | `from scrapling.parser import Selector` |
+| HTML aus einer Zeichenfolge parsen | `soup = BeautifulSoup(html, 'html.parser')` | `page = Selector(html)` |
+| Ein Element finden | `element = soup.find('div', class_='example')` | `element = page.find('div', class_='example')` |
+| Mehrere Elemente finden | `elements = soup.find_all('div', class_='example')` | `elements = page.find_all('div', class_='example')` |
+| Ein Element finden (Beispiel 2) | `element = soup.find('div', attrs={"class": "example"})` | `element = page.find('div', {"class": "example"})` |
+| Ein Element finden (Beispiel 3) | `element = soup.find(re.compile("^b"))` | `element = page.find(lambda e: re.search(r"^b", e.tag) is not None)` |
+| Ein Element finden (Beispiel 4) | `element = soup.find(lambda e: len(list(e.children)) > 0)` | `element = page.find(lambda e: len(e.children) > 0)` |
+| Ein Element finden (Beispiel 5) | `element = soup.find(["a", "b"])` | `element = page.find(["a", "b"])` |
+| Ein Element anhand seines Texts finden | `element = soup.find(text="some text")` | `element = page.find_by_text("some text", partial=False)` |
+| Den ersten Treffer mit CSS auswählen | `elements = soup.select_one('div.example')` | `elements = page.css('div.example').first` |
+| Alle Treffer mit CSS auswählen | `elements = soup.select('div.example')` | `elements = page.css('div.example')` |
+| Den Quelltext einer Seite oder eines Elements lesbar formatieren | `prettified = soup.prettify()` | `prettified = page.prettify()` |
+| Den Quelltext einer Seite oder eines Elements ohne zusätzliche Formatierung erhalten | `source = str(soup)` | `source = page.html_content` |
+| Den Tag-Namen eines Elements erhalten | `name = element.name` | `name = element.tag` |
+| Den Text eines Elements extrahieren | `string = element.string` | `string = element.text` |
+| Den gesamten Text eines Dokuments oder unter einem Tag extrahieren | `text = soup.get_text(strip=True)` | `text = page.get_all_text(strip=True)` |
+| Auf das Wörterbuch der Attribute zugreifen | `attrs = element.attrs` | `attrs = element.attrib` |
+| Attribute extrahieren | `attr = element['href']` | `attr = element['href']` |
+| Zum Elternelement wechseln | `parent = element.parent` | `parent = element.parent` |
+| Alle Vorfahren eines Elements erhalten | `parents = list(element.parents)` | `parents = list(element.iterancestors())` |
+| Ein Element unter den Vorfahren suchen | `target_parent = element.find_parent("a")` | `target_parent = element.find_ancestor(lambda p: p.tag == 'a')` |
+| Alle Geschwisterelemente erhalten | Nicht verfügbar | `siblings = element.siblings` |
+| Das nächste Geschwisterelement erhalten | `next_element = element.next_sibling` | `next_element = element.next` |
+| Ein Geschwisterelement suchen | `target_sibling = element.find_next_sibling("a")`<br/>`target_sibling = element.find_previous_sibling("a")` | `target_sibling = element.siblings.search(lambda s: s.tag == 'a')` |
+| Mehrere Geschwisterelemente suchen | `target_sibling = element.find_next_siblings("a")`<br/>`target_sibling = element.find_previous_siblings("a")` | `target_sibling = element.siblings.filter(lambda s: s.tag == 'a')` |
+| Ein Element unter den folgenden Elementen suchen | `target_parent = element.find_next("a")` | `target_parent = element.below_elements.search(lambda p: p.tag == 'a')` |
+| Mehrere Elemente unter den folgenden Elementen suchen | `target_parent = element.find_all_next("a")` | `target_parent = element.below_elements.filter(lambda p: p.tag == 'a')` |
+| Ein Element unter den Vorfahren suchen | `target_parent = element.find_previous("a")` ¹ | `target_parent = element.path.search(lambda p: p.tag == 'a')` |
+| Mehrere Elemente unter den Vorfahren suchen | `target_parent = element.find_all_previous("a")` ¹ | `target_parent = element.path.filter(lambda p: p.tag == 'a')` |
+| Das vorherige Geschwisterelement erhalten | `prev_element = element.previous_sibling` | `prev_element = element.previous` |
+| Zu den Kindelementen wechseln | `children = list(element.children)` | `children = element.children` |
+| Alle Nachfahren eines Elements erhalten | `children = list(element.descendants)` | `children = element.below_elements` |
+| Links in Absätzen mit der Klasse story auswählen | `group = soup.select('p.story a')` | `group = page.css('p.story a')` |
+
+Eine kompilierte Regex, die Sie direkt an Scraplings `find()` oder `find_all()` übergeben, durchsucht den Text der Elemente, nicht ihre Tag-Namen. Für Tag-Namen nutzen Sie die Lambda-Funktion aus der Tabelle. Für direkten Text können Sie `page.find_by_regex(r"^b")` verwenden.
+
+¹ **Hinweis:** `find_previous`/`find_all_previous` von BS4 durchsuchen alle vorhergehenden Elemente in Dokumentreihenfolge. Scraplings `path` gibt dagegen nur Vorfahren zurück, also die Kette der Elternelemente. Die Methoden sind nicht genau gleich, aber die Suche unter den Vorfahren deckt den häufigsten Fall ab.
+
+**Ein wichtiger Unterschied**: BeautifulSoup bietet Funktionen, um eine Seite nach dem Parsen zu verändern. Scrapling konzentriert sich darauf, Daten schnell zu extrahieren. Danach können Sie die Daten beliebig weiterverarbeiten. Beide Werkzeuge können beim Web Scraping helfen, aber eines ist darauf spezialisiert :)
+
+### Ein vollständiges Beispiel {#putting-it-all-together}
+
+Dieses einfache Beispiel extrahiert alle Links einer Webseite mit BeautifulSoup und Scrapling.
+
+**Mit BeautifulSoup:**
+
+```python
+import requests
+from bs4 import BeautifulSoup
+
+url = 'https://example.com'
+response = requests.get(url)
+soup = BeautifulSoup(response.text, 'html.parser')
+
+links = soup.find_all('a')
+for link in links:
+ print(link['href'])
+```
+
+**Mit Scrapling:**
+
+```python
+from scrapling import Fetcher
+
+url = 'https://example.com'
+page = Fetcher.get(url)
+
+links = page.css('a::attr(href)').getall()
+for link in links:
+ print(link)
+```
+
+Scrapling verbindet das Abrufen und Parsen in einem Schritt. So wird Ihr Code einfacher und effizienter.
+
+!!! abstract "**Weitere Hinweise:**"
+
+ - **Verschiedene Parser**: In BeautifulSoup können Sie den Parser auswählen, zum Beispiel `lxml`. Scrapling verwendet aus Leistungsgründen standardmäßig die Bibliothek `lxml`.
+ - **Elementtypen**: In BeautifulSoup sind Elemente `Tag`-Objekte, in Scrapling `Selector`-Objekte. Beide bieten ähnliche Methoden und Eigenschaften für Navigation und Datenextraktion.
+ - **Fehlerbehandlung**: Beide Bibliotheken geben `None` zurück, wenn sie kein Element finden, zum Beispiel mit `soup.find()` oder `page.find()`. In Scrapling gibt `page.css()` eine leere `Selectors`-Liste zurück, wenn nichts passt. Mit `page.css('.foo').first` erhalten Sie sicher den ersten Treffer oder `None`. Prüfen Sie auf `None` oder leere Ergebnisse, bevor Sie auf Eigenschaften zugreifen.
+ - **Textextraktion**: Scrapling bietet über `TextHandler` zusätzliche Methoden zur Textverarbeitung, etwa `clean()`. Diese Methode hilft, überflüssige Leerzeichen, aufeinanderfolgende Leerzeichen oder unerwünschte Zeichen zu entfernen. Die vollständige Liste finden Sie in der Dokumentation.
+
+Die Dokumentation beschreibt die Funktionen von Scrapling genauer und enthält die vollständige Liste aller Argumente der Methoden.
+
+Diese Anleitung soll Ihnen den Wechsel von BeautifulSoup zu Scrapling erleichtern. Viel Erfolg beim Scraping!
diff --git a/docs/locales/de/tutorials/replacing_ai.md b/docs/locales/de/tutorials/replacing_ai.md
new file mode 100644
index 0000000..f4c6444
--- /dev/null
+++ b/docs/locales/de/tutorials/replacing_ai.md
@@ -0,0 +1,121 @@
+---
+title: "Eine kostenlose Alternative zu KI für zuverlässiges Web Scraping"
+description: "Scrapling hilft bei geänderten Seiten, instabilen Selektoren, Bot-Schutz und Seitennavigation, ohne für jede Seite ein LLM aufzurufen."
+---
+
+# Scrapling: Eine kostenlose Alternative zu KI für zuverlässiges Web Scraping {#scrapling-a-free-alternative-to-ai-for-robust-web-scraping}
+
+Web Scraping wird seit Langem genutzt, um Daten zu sammeln, Inhalte zu indexieren und Datensätze vorzubereiten. Erfahrene Nutzer stoßen dabei oft auf Probleme, die ihre Arbeit erschweren. In letzter Zeit wächst das Interesse an Web Scraping mit KI, weil sie einen Teil dieser Probleme lösen kann.
+
+In diesem Artikel sehen wir uns die häufigsten Probleme an. Wir erklären, warum Unternehmen KI einsetzen, welche Grenzen dieser Ansatz hat und wie Scrapling ohne die Kosten von KI helfen kann.
+
+## Häufige Probleme und schwierige Ziele {#common-issues-and-challenging-goals}
+
+Wenn Sie schon länger Web Scraping betreiben, kennen Sie wahrscheinlich diese wiederkehrenden Probleme:
+
+1. **Häufige Änderungen an der Seitenstruktur**: Websites ändern ihren DOM. Feste XPath- oder CSS-Selektoren funktionieren dann nicht mehr.
+2. **Instabile Selektoren**: Klassennamen und IDs ändern sich oder werden zufällig erzeugt. Das lässt Scraper scheitern oder erschwert die Datenextraktion.
+3. **Immer komplexerer Bot-Schutz**: CAPTCHA-Systeme, Browser-Fingerprinting und Verhaltensanalysen erschweren klassisches Scraping.
+
+Und das sind noch nicht alle. Diese Probleme treten schon bei bekannten Websites auf, für die Sie jeweils eigenen Code schreiben können.
+
+Wenn Sie größere Ziele haben und viele verschiedene Websites abdecken wollen, oft Broad Scraping oder Generic Web Scraping genannt, werden diese Probleme größer. Weitere kommen hinzu:
+
+1. **Sehr unterschiedliche Websites**: Ein allgemeiner Scraper muss viele HTML-Strukturen, CSS-Nutzungsweisen, JavaScript-Frameworks und Backend-Technologien unterstützen.
+2. **Wichtige Daten erkennen**: Woher weiß der Scraper, welche Daten auf einer unbekannten Seite wichtig sind?
+3. **Verschiedene Arten der Seitennavigation**: Endloses Scrollen, nummerierte Seiten und Schaltflächen zum Nachladen brauchen unterschiedliche Ansätze.
+
+Die Liste geht weiter. Wie lösen Sie das alles von Hand? Gemeint sind verschiedene Websites, die keine gemeinsamen Technologien verwenden.
+
+## KI hilft, kostet aber viel {#ai-to-the-rescue-but-at-a-high-cost}
+
+KI kann viele dieser Probleme lösen, weil sie den Quelltext der Seite versteht, gewünschte Felder erkennt oder Selektoren dafür erstellt. Natürlich setzt das voraus, dass Sie den Bot-Schutz bereits mit anderen Werkzeugen umgehen :)
+
+Ich mag diesen Ansatz. KI fasziniert mich, besonders generative KI. Sie werden wahrscheinlich viel Zeit damit verbringen, Prompts zu schreiben und anzupassen. Wenn Sie damit zufrieden sind, stoßen Sie bald auf das eigentliche Problem beim Einsatz von KI in diesem Fall.
+
+Viele Seiten enthalten sehr große Mengen an Inhalt. Diesen müssen Sie dem Modell irgendwie übergeben. Dabei werden schnell viele Tokens verbraucht, und die Kosten steigen rasch.
+
+Wenn Geld für Sie eine Rolle spielt, werden Sie nach günstigeren Lösungen suchen. Hier kommt Scrapling ins Spiel :smile:
+
+## Scrapling hilft Ihnen {#scrapling-got-you-covered}
+
+Scrapling kann fast alle Probleme bewältigen, die Ihnen beim Web Scraping begegnen. Die nächsten Updates werden die übrigen abdecken.
+
+### Problem T1 lösen: Häufige Änderungen an der Seitenstruktur {#solving-issue-t1-rapidly-changing-website-structures}
+
+Dafür wurde die Funktion [adaptive](../parsing/adaptive.md) entwickelt. Sie wussten, dass ich darauf zurückkommen würde, und jetzt ist es so weit :)
+
+Wenn `adaptive` aktiviert ist, können Sie die besonderen Eigenschaften eines Elements speichern. So finden Sie es später wieder, auch wenn sich die Struktur der Website ändert. Das Schwierige ist, dass sich jeder Teil eines Elements ändern kann. Es gibt also nicht immer eine feste Eigenschaft, auf die Sie sich verlassen können.
+
+Die Funktion speichert alles, was das Element auszeichnet. Wenn die Website ihre Struktur ändert, gibt sie das Element zurück, das dem früheren Element am ähnlichsten ist.
+
+Ich habe das bereits mit mehreren Beispielen ausführlich erklärt. Lesen Sie [hier](../parsing/adaptive.md#how-the-adaptive-scraping-feature-works) mehr dazu.
+
+### Problem T2 lösen: Instabile Selektoren {#solving-issue-t2-unstable-selectors}
+
+Wenn Sie schon lange Daten von Websites extrahieren, ist Ihnen das wahrscheinlich schon begegnet: eine HTML-Seite ohne IDs oder Klassen, zufällige Klassennamen oder eine Struktur, die keine stabilen Merkmale zur Auswahl bietet.
+
+In solchen Fällen sind klassische CSS- oder XPath-Selektoren nicht immer die beste Wahl. Deshalb bietet Scrapling drei weitere Möglichkeiten zur Auswahl von Elementen:
+
+1. [Nach Inhalt auswählen](../parsing/selection.md#text-content-selection): Suchen Sie nach Text mit `find_by_text` oder nach einer passenden Regex mit `find_by_regex`.
+2. [Ähnliche Elemente auswählen](../parsing/selection.md#finding-similar-elements): Sie finden ein Element, und wir suchen die anderen.
+3. [Mit Filtern auswählen](../parsing/selection.md#filters-based-searching): Sie geben die Bedingungen an, die ein Element erfüllen muss, und wir finden es.
+
+Öffnen Sie die Links, um zu sehen, wie Scrapling die einzelnen Fälle löst.
+
+### Problem T3 lösen: Immer komplexerer Bot-Schutz {#solving-issue-t3-increasingly-complex-anti-bot-measures}
+
+Proxies und menschenähnliche Aktionen allein reichen bei geschützten Websites nicht immer aus. [StealthyFetcher](../fetching/stealthy.md) verbindet Browser-Automatisierung mit Anpassungen des Fingerprints und Optionen gegen Bot-Schutz. Aktivieren Sie `solve_cloudflare=True` für die Turnstile- und Interstitial-Prüfungen von Cloudflare.
+
+### Probleme B1 und B2 lösen: Unterschiedliche Websites und wichtige Daten {#solving-issues-b1-b2-extreme-website-diversity-identifying-relevant-data}
+
+Dieses Problem ist schwierig. Die Flexibilität von Scrapling macht es aber lösbar.
+
+Ich habe mit jemandem gesprochen, der KI nutzt, um Preise auf verschiedenen Websites zu finden. Ihn interessieren nur Preise und Titel, deshalb lässt er die KI den Preis suchen.
+
+Ich sagte ihm, dass er dafür keine KI braucht, und zeigte diesen Code:
+```python
+price_element = page.find_by_regex(r'£[\d\.,]+', first_match=True) # Get the first element that contains a text that matches price regex eg. £10.50
+# If you want the container/element that contains the price element
+price_element_container = price_element.parent or price_element.find_ancestor(lambda ancestor: ancestor.has_class('product')) # or other methods...
+target_element_selector = price_element_container.generate_css_selector or price_element_container.generate_full_css_selector # or xpath
+```
+Dann fragte er nach einem Fall wie diesem:
+```html
+<span class='currency'> $ </span> <span class='a-price'> 45,000 </span>
+```
+Also passte ich den Code an:
+```python
+price_element_container = page.find_by_regex(r'[\d,]+', first_match=True).parent # Adjusted the regex for this example
+full_price_data = price_element_container.get_all_text(separator="", strip=True) # Returns '$45,000' in this case
+```
+Das reichte für seinen Fall. Sie können zuerst die erste Regex versuchen und zur nächsten wechseln, wenn sie nichts findet. Decken Sie zuerst die häufigsten Muster ab, dann die selteneren.
+Das ist vielleicht etwas mühsam, aber deutlich günstiger als KI.
+
+Darum geht es in diesem Beispiel: Nicht jedes Problem braucht KI. Manchmal spart Ihnen eine andere Lösung viel Geld.
+
+### Problem B3 lösen: Verschiedene Arten der Seitennavigation {#solving-issue-b3-pagination-variations}
+
+Scrapling hat noch keine direkte Methode, um Links zur nächsten Seite automatisch zu erkennen. Seine Spider folgen diesen Links mit `response.follow()`.
+
+Sie können aber viele Websites abdecken, indem Sie nach häufigen Mustern suchen. Nutzen Sie zum Beispiel `page.find_by_text('Next')['href']` oder `page.find_by_text('load more')['href']`, oder Selektoren wie `'a[href*="?page="]'` oder `'a[href*="/page/"]'`. Sie sehen die Idee.
+
+## Kostenvergleich und Einsparungen {#cost-comparison-and-savings}
+
+Hier ist ein kurzer Vergleich:
+
+| Aspekt | Scrapling | Werkzeuge mit KI, etwa Browse AI oder Oxylabs |
+|---|---|---|
+| Kosten | Kostenlos, ohne Bibliotheksgebühren pro Nutzung | Kostenpflichtige Tarife, abhängig von Anbieter und Nutzung |
+| Einrichtung | Erfordert etwas technisches Wissen und manuelle Einrichtung | Oft ohne Code nutzbar und daher einfacher ohne technisches Wissen |
+| Nutzung | Über Code, Terminal oder MCP-Server | Oft über eine grafische Oberfläche oder API, je nach Angebot |
+| Skalierung | Hängt von der Umsetzung durch den Nutzer ab | Verwaltete Dienste mit Unterstützung für große Datenmengen |
+| Anpassung an Änderungen | Hoch durch `adaptive` und Auswahlmethoden ohne CSS- oder XPath-Selektoren | Hoch und automatisch mit KI, aber bei häufigen Änderungen teuer |
+
+Aktuelle Preise finden Sie bei [Browse AI](https://www.browse.ai/pricing) und der [Web Scraper API von Oxylabs](https://oxylabs.io/products/scraper-api/web/pricing).
+
+## Fazit {#conclusion}
+
+KI bietet viele starke Funktionen. Ihre Kosten können für zahlreiche Scraping-Aufgaben aber zu hoch sein. Scrapling bietet zuverlässige, flexible und günstige Werkzeuge für einzelne bekannte Websites und für viele verschiedene Websites. Damit lässt sich der Einsatz teurer KI-Lösungen oft vermeiden. Mit `adaptive`, verschiedenen Auswahlmethoden und fortgeschrittenen Fetchern können Sie Scraper erstellen, die mit Änderungen besser umgehen.
+
+Lesen Sie weiter in der Dokumentation und entdecken Sie, wie Scrapling Ihre nächsten Web-Scraping-Projekte vereinfachen kann!
diff --git a/docs/overrides/api/python/material/languages/de.html.jinja b/docs/overrides/api/python/material/languages/de.html.jinja
new file mode 100644
index 0000000..0a156e7
--- /dev/null
+++ b/docs/overrides/api/python/material/languages/de.html.jinja
@@ -0,0 +1,17 @@
+{% macro t(key) %}{{ {
+ "ATTRIBUTE": "ATTRIBUT", "Attributes": "Attribute", "Attributes:": "Attribute:",
+ "BOUND:": "OBERGRENZE:", "Bound or Constraints": "Obergrenze oder Einschränkungen",
+ "Classes": "Klassen", "Classes:": "Klassen:", "CLASS": "KLASSE",
+ "Class Type Parameters:": "Typparameter der Klasse:", "CLASS TYPE PARAMETER": "TYPPARAMETER DER KLASSE",
+ "CONSTRAINTS:": "EINSCHRÄNKUNGEN:", "DEFAULT:": "STANDARDWERT:", "Default": "Standardwert", "default:": "Standardwert:",
+ "DESCRIPTION": "BESCHREIBUNG", "Description": "Beschreibung", "Examples:": "Beispiele:",
+ "Functions": "Funktionen", "Functions:": "Funktionen:", "FUNCTION": "FUNKTION",
+ "Init Type Parameters:": "Typparameter der Initialisierung:", "INIT TYPE PARAMETER": "TYPPARAMETER DER INITIALISIERUNG",
+ "Methods:": "Methoden:", "METHOD": "METHODE", "Modules": "Module", "Modules:": "Module:", "MODULE": "MODUL",
+ "Name": "Name", "Other Parameters:": "Weitere Parameter:", "PARAMETER": "PARAMETER", "Parameters:": "Parameter:",
+ "RAISES": "AUSNAHMEN", "Raises:": "Ausnahmen:", "RECEIVES": "EMPFÄNGT", "Receives:": "Empfängt:",
+ "required": "erforderlich", "RETURNS": "RÜCKGABE", "Returns:": "Rückgabe:", "Source code in": "Quellcode in",
+ "TYPE:": "TYP:", "Type": "Typ", "Type Aliases": "Typaliase", "Type Aliases:": "Typaliase:",
+ "TYPE ALIAS": "TYPALIAS", "Type Parameters:": "Typparameter:", "TYPE PARAMETER": "TYPPARAMETER",
+ "WARNS": "WARNUNGEN", "Warns:": "Warnungen:", "YIELDS": "LIEFERT", "Yields:": "Liefert:"
+}.get(key, "") }}{% endmacro %}
diff --git a/docs/overrides/api/python/material/translations/de.html.jinja b/docs/overrides/api/python/material/translations/de.html.jinja
new file mode 100644
index 0000000..14cee35
--- /dev/null
+++ b/docs/overrides/api/python/material/translations/de.html.jinja
@@ -0,0 +1,369 @@
+{% set translations = {
+ "<p>This class is returned by all engines as a way to unify the response type between different libraries.</p>": "<p>Alle Engines geben diese Klasse zurück, damit verschiedene Bibliotheken denselben Antworttyp verwenden.</p>",
+ "<p>HTTP status code.</p>": "<p>HTTP-Statuscode.</p>",
+ "<p>HTTP status message.</p>": "<p>HTTP-Statusmeldung.</p>",
+ "<p>Response cookies.</p>": "<p>Cookies der Antwort.</p>",
+ "<p>Response headers.</p>": "<p>Header der Antwort.</p>",
+ "<p>Request headers sent with the request.</p>": "<p>Mit der Anfrage gesendete Header.</p>",
+ "<p>List of redirect responses, if any.</p>": "<p>Liste der Weiterleitungsantworten, falls vorhanden.</p>",
+ "<p>Metadata dictionary (e.g., proxy used).</p>": "<p>Dictionary mit Metadaten, etwa dem verwendeten Proxy.</p>",
+ "<p>Associated spider Request object (set by crawler, in the spiders framework).</p>": "<p>Zugehöriges Request-Objekt des Spiders. Wird im Spider-Framework vom Crawler gesetzt.</p>",
+ "<p>The main class that works as a wrapper for the HTML input data. Using this class, you can search for elements\nwith expressions in CSS, XPath, or with simply text. Check the docs for more info.</p>": "<p>Die Hauptklasse für die HTML-Eingabedaten. Mit ihr suchen Sie Elemente über CSS, XPath oder einfachen Text. Weitere Informationen finden Sie in der Dokumentation.</p>",
+ "<p>Here we try to extend module <code>lxml.html.HtmlElement</code> while maintaining a simpler interface, We are not\ninheriting from the <code>lxml.html.HtmlElement</code> because it's not pickleable, which makes a lot of reference jobs\nnot possible. You can test it here and see code explodes with <code>AssertionError: invalid Element proxy at...</code>.\nIt's an old issue with lxml, see <code>this entry &lt;https://bugs.launchpad.net/lxml/+bug/736708&gt;</code></p>": "<p>Diese Klasse erweitert die Funktionen von <code>lxml.html.HtmlElement</code> mit einer einfacheren Schnittstelle. Sie erbt nicht von <code>lxml.html.HtmlElement</code>, da dieser Typ nicht mit pickle gespeichert werden kann. Das verhindert viele Vorgänge, die Referenzen verwenden. Bei einem Versuch erhalten Sie <code>AssertionError: invalid Element proxy at...</code>. Das ist ein älteres Problem von lxml, siehe <code>this entry &lt;https://bugs.launchpad.net/lxml/+bug/736708&gt;</code>.</p>",
+ "<p>HTML content as either string or bytes.</p>": "<p>HTML-Inhalt als String oder Bytes.</p>",
+ "<p>It allows storing a URL with the HTML data for retrieving later.</p>": "<p>Erlaubt das Speichern einer URL zusammen mit den HTML-Daten, um sie später abzurufen.</p>",
+ "<p>The encoding type that will be used in HTML parsing, default is <code>UTF-8</code></p>": "<p>Zeichenkodierung für das Parsen von HTML. Standardmäßig <code>UTF-8</code>.</p>",
+ "<p>Enabled by default, should always be enabled when parsing large HTML documents. This controls\nthe libxml2 feature that forbids parsing certain large documents to protect from possible memory exhaustion.</p>": "<p>Standardmäßig aktiviert und beim Parsen großer HTML-Dokumente immer zu aktivieren. Steuert die Funktion von libxml2, die das Parsen bestimmter großer Dokumente verhindert, um den Speicher vor Überlastung zu schützen.</p>",
+ "<p>Used internally to pass etree objects instead of text/body arguments, it takes the highest priority.\nDon't use it unless you know what you are doing!</p>": "<p>Wird intern verwendet, um etree-Objekte statt Text- oder Body-Argumenten zu übergeben. Hat die höchste Priorität. Verwenden Sie es nur, wenn Sie die Auswirkungen kennen.</p>",
+ "<p>While parsing the HTML body, drop comments or not. Disabled by default for obvious reasons</p>": "<p>Legt fest, ob Kommentare beim Parsen des HTML-Bodys erhalten bleiben. Standardmäßig deaktiviert.</p>",
+ "<p>Globally turn off the adaptive feature in all functions, this argument takes higher\npriority over all adaptive related arguments/functions in the class.</p>": "<p>Schaltet die adaptive Funktion in allen Methoden aus. Dieses Argument hat Vorrang vor allen Argumenten und Methoden der Klasse, die adaptive Funktionen betreffen.</p>",
+ "<p>The storage class to be passed for adaptive functionalities, see <code>Docs</code> for more info.</p>": "<p>Speicherklasse für die adaptiven Funktionen. Weitere Informationen finden Sie unter <code>Docs</code>.</p>",
+ "<p>A dictionary of <code>argument-&gt;value</code> pairs to be passed for the storage class.\nIf empty, default values will be used.</p>": "<p>Dictionary mit Paaren aus <code>argument-&gt;value</code>, die an die Speicherklasse übergeben werden. Ist es leer, werden die Standardwerte verwendet.</p>",
+ "<p>Return the raw body of the current <code>Selector</code> without any processing. Useful for binary and non-HTML requests.</p>": "<p>Gibt den unverarbeiteten Body des aktuellen <code>Selector</code> zurück. Nützlich für Binärdaten und andere Inhalte als HTML.</p>",
+ "<p>Return the raw body of the response as bytes.</p>": "<p>Gibt den unverarbeiteten Body der Antwort als Bytes zurück.</p>",
+ "<p>Generate a CSS selector for the current element</p>": "<p>Erstellt einen CSS-Selektor für das aktuelle Element.</p>",
+ "<p>A string of the generated selector.</p>": "<p>String mit dem erstellten Selektor.</p>",
+ "<p>Generate a complete CSS selector for the current element</p>": "<p>Erstellt einen vollständigen CSS-Selektor für das aktuelle Element.</p>",
+ "<p>Generate an XPath selector for the current element</p>": "<p>Erstellt einen XPath-Selektor für das aktuelle Element.</p>",
+ "<p>Generate a complete XPath selector for the current element</p>": "<p>Erstellt einen vollständigen XPath-Selektor für das aktuelle Element.</p>",
+ "<p>Get the tag name of the element</p>": "<p>Gibt den Tag-Namen des Elements zurück.</p>",
+ "<p>Get text content of the element</p>": "<p>Gibt den Textinhalt des Elements zurück.</p>",
+ "<p>Get attributes of the element</p>": "<p>Gibt die Attribute des Elements zurück.</p>",
+ "<p>Return the inner HTML code of the element</p>": "<p>Gibt den inneren HTML-Code des Elements zurück.</p>",
+ "<p>Return the direct parent of the element or <code>None</code> otherwise</p>": "<p>Gibt das direkte Elternelement zurück, andernfalls <code>None</code>.</p>",
+ "<p>Return all elements under the current element in the DOM tree</p>": "<p>Gibt alle Elemente unterhalb des aktuellen Elements im DOM-Baum zurück.</p>",
+ "<p>Return the children elements of the current element or empty list otherwise</p>": "<p>Gibt die Kindelemente des aktuellen Elements zurück, andernfalls eine leere Liste.</p>",
+ "<p>Return other children of the current element's parent or empty list otherwise</p>": "<p>Gibt die anderen Kinder des Elternelements zurück, andernfalls eine leere Liste.</p>",
+ "<p>Returns a list of type <code>Selectors</code> that contains the path leading to the current element from the root.</p>": "<p>Gibt eine Liste vom Typ <code>Selectors</code> zurück, die den Pfad von der Wurzel zum aktuellen Element enthält.</p>",
+ "<p>Returns the next element of the current element in the children of the parent or <code>None</code> otherwise.</p>": "<p>Gibt das nächste Element unter den Kindern desselben Elternelements zurück, andernfalls <code>None</code>.</p>",
+ "<p>Returns the previous element of the current element in the children of the parent or <code>None</code> otherwise.</p>": "<p>Gibt das vorherige Element unter den Kindern desselben Elternelements zurück, andernfalls <code>None</code>.</p>",
+ "<p>Convert the response content to clean Markdown.</p>": "<p>Wandelt den Antwortinhalt in bereinigtes Markdown um.</p>",
+ "<p>Scripts, styles, and hidden/prompt-injection content are always removed before conversion, which is\nthe same cleaning the MCP server does. Requires the \"markdownify\" package (<code>pip install \"scrapling[rag]\"</code>).</p>": "<p>Vor der Umwandlung werden Skripte, Styles und versteckte Inhalte oder Inhalte mit eingeschleusten Anweisungen immer entfernt. Das entspricht der Bereinigung im MCP-Server. Erfordert das Paket \"markdownify\" (<code>pip install \"scrapling[rag]\"</code>).</p>",
+ "<p>CSS selector to convert only the matching elements. All matches are concatenated.</p>": "<p>CSS-Selektor, um nur passende Elemente umzuwandeln. Alle Treffer werden zusammengefügt.</p>",
+ "<p>Convert only the content inside the <code>&lt;body&gt;</code> tag.</p>": "<p>Wandelt nur den Inhalt innerhalb des Tags <code>&lt;body&gt;</code> um.</p>",
+ "<p>Create a Request to follow a URL.</p>": "<p>Erstellt einen Request, um einer URL zu folgen.</p>",
+ "<p>This is a helper method for spiders to easily follow links found in pages.</p>": "<p>Hilfsmethode, mit der Spider einfach Links aus Seiten folgen können.</p>",
+ "<p><strong>IMPORTANT</strong>: The below arguments if left empty, the corresponding value from the previous request will be used. The only exception is <code>dont_filter</code>.</p>": "<p><strong>WICHTIG</strong>: Wenn die folgenden Argumente leer bleiben, wird jeweils der Wert der vorherigen Anfrage verwendet. Die einzige Ausnahme ist <code>dont_filter</code>.</p>",
+ "<p>The session kwargs of the previous request are inherited as well, except <code>method</code>, <code>params</code>, <code>data</code>, <code>json</code>, <code>files</code>, and <code>multipart</code>, so a followed link is a plain GET unless you pass them again.</p>": "<p>Die Sitzungsargumente der vorherigen Anfrage werden ebenfalls übernommen, außer <code>method</code>, <code>params</code>, <code>data</code>, <code>json</code>, <code>files</code> und <code>multipart</code>. Einem Link wird daher mit einem einfachen GET gefolgt, sofern Sie diese Argumente nicht erneut übergeben.</p>",
+ "<p>The URL to follow (can be relative, will be joined with current URL)</p>": "<p>URL, der gefolgt werden soll. Sie darf relativ sein und wird dann mit der aktuellen URL verbunden.</p>",
+ "<p>The session id to use</p>": "<p>ID der zu verwendenden Sitzung.</p>",
+ "<p>Spider callback method to use</p>": "<p>Zu verwendende Callback-Methode des Spiders.</p>",
+ "<p>The priority number to use, the higher the number, the higher priority to be processed first.</p>": "<p>Prioritätswert. Je höher der Wert, desto früher wird die Anfrage verarbeitet.</p>",
+ "<p>If this request has been done before, disable the filter to allow it again.</p>": "<p>Schaltet den Filter aus, damit eine bereits ausgeführte Anfrage erneut erlaubt ist.</p>",
+ "<p>Additional meta data to included in the request</p>": "<p>Zusätzliche Metadaten für die Anfrage.</p>",
+ "<p>Enabled by default, set the current response url as referer for the new request url.</p>": "<p>Standardmäßig aktiviert. Setzt die URL der aktuellen Antwort als Referer für die neue Anfrage.</p>",
+ "<p>Additional Request arguments</p>": "<p>Zusätzliche Request-Argumente.</p>",
+ "<p>Request object ready to be yielded</p>": "<p>Request-Objekt, das mit yield ausgegeben werden kann.</p>",
+ "<p>Get all child strings of this element, concatenated using the given separator.</p>": "<p>Gibt alle untergeordneten Strings dieses Elements zurück, verbunden durch das angegebene Trennzeichen.</p>",
+ "<p>Strings will be concatenated using this separator.</p>": "<p>Trennzeichen zum Verbinden der Strings.</p>",
+ "<p>If True, strings will be stripped before being concatenated.</p>": "<p>Wenn True, wird Leerraum am Anfang und Ende der Strings vor dem Verbinden entfernt.</p>",
+ "<p>A tuple of all tag names you want to ignore</p>": "<p>Tupel mit allen zu ignorierenden Tag-Namen.</p>",
+ "<p>If enabled, elements with text-content that is empty or only whitespaces will be ignored</p>": "<p>Wenn aktiviert, werden Elemente ignoriert, deren Text leer ist oder nur aus Leerraum besteht.</p>",
+ "<p>A TextHandler</p>": "<p>Ein TextHandler.</p>",
+ "<p>Join this Selector's url with a relative url to form an absolute full URL.</p>": "<p>Verbindet die URL dieses Selectors mit einer relativen URL zu einer vollständigen absoluten URL.</p>",
+ "<p>Return a prettified version of the element's inner html-code</p>": "<p>Gibt den inneren HTML-Code des Elements in lesbar formatiertem Zustand zurück.</p>",
+ "<p>Check if the element has a specific class</p>": "<p>Prüft, ob das Element eine bestimmte Klasse hat.</p>",
+ "<p>The class name to check for</p>": "<p>Name der zu prüfenden Klasse.</p>",
+ "<p>True if element has class with that name otherwise False</p>": "<p>True, wenn das Element eine Klasse mit diesem Namen hat, andernfalls False.</p>",
+ "<p>Return a generator that loops over all ancestors of the element, starting with the element's parent.</p>": "<p>Gibt einen Generator zurück, der alle Vorfahren des Elements durchläuft, beginnend mit dem Elternelement.</p>",
+ "<p>Loop over all ancestors of the element till one match the passed function</p>": "<p>Durchläuft die Vorfahren des Elements, bis einer die übergebene Funktion erfüllt.</p>",
+ "<p>A function that takes each ancestor as an argument and returns True/False</p>": "<p>Funktion, die jeden Vorfahren als Argument erhält und True oder False zurückgibt.</p>",
+ "<p>The first ancestor that match the function or <code>None</code> otherwise.</p>": "<p>Der erste Vorfahr, der die Funktion erfüllt, andernfalls <code>None</code>.</p>",
+ "<p>Serialize this element to a string.\nFor text nodes, returns the text value. For HTML elements, returns the outer HTML.</p>": "<p>Wandelt dieses Element in einen String um. Bei Textknoten wird der Textwert zurückgegeben, bei HTML-Elementen das äußere HTML.</p>",
+ "<p>Return a single-element list containing this element's serialized string.</p>": "<p>Gibt eine Liste mit einem Eintrag zurück: dem als String dargestellten Element.</p>",
+ "<p>This function will search again for the element in the page tree, used automatically on page structure change</p>": "<p>Sucht das Element erneut im Seitenbaum. Wird bei Änderungen der Seitenstruktur automatisch verwendet.</p>",
+ "<p>The element we want to relocate in the tree</p>": "<p>Das Element, das im Baum wiedergefunden werden soll.</p>",
+ "<p>The minimum percentage to accept and not going lower than that. Be aware that the percentage\ncalculation depends solely on the page structure, so don't play with this number unless you must know\nwhat you are doing!</p>": "<p>Der niedrigste erlaubte Prozentsatz für eine Übereinstimmung. Die Berechnung hängt nur von der Seitenstruktur ab. Ändern Sie diesen Wert nur, wenn Sie die Auswirkungen kennen.</p>",
+ "<p>If True, the return result will be converted to <code>Selectors</code> object</p>": "<p>Wenn True, wird das Ergebnis in ein <code>Selectors</code>-Objekt umgewandelt.</p>",
+ "<p>List of pure HTML elements that got the highest matching score or 'Selectors' object</p>": "<p>Liste der reinen HTML-Elemente mit der höchsten Übereinstimmung oder ein 'Selectors'-Objekt.</p>",
+ "<p>Search the current tree with CSS3 selectors</p>": "<p>Durchsucht den aktuellen Baum mit CSS3-Selektoren.</p>",
+ "<p><strong>Important:\nIt's recommended to use the identifier argument if you plan to use a different selector later\nand want to relocate the same element(s)</strong></p>": "<p><strong>Wichtig: Verwenden Sie am besten das Argument identifier, wenn Sie später einen anderen Selektor verwenden und dieselben Elemente wiederfinden möchten.</strong></p>",
+ "<p>The CSS3 selector to be used.</p>": "<p>Der zu verwendende CSS3-Selektor.</p>",
+ "<p>Enabled will make the function try to relocate the element if it was 'saved' before</p>": "<p>Wenn aktiviert, versucht die Funktion, ein zuvor gespeichertes Element wiederzufinden.</p>",
+ "<p>A string that will be used to save/retrieve element's data in adaptive,\notherwise the selector will be used.</p>": "<p>String zum Speichern und Abrufen der Elementdaten für adaptive Funktionen. Ohne Angabe wird der Selektor verwendet.</p>",
+ "<p>Automatically save new elements for <code>adaptive</code> later</p>": "<p>Speichert neue Elemente automatisch für die spätere Verwendung mit <code>adaptive</code>.</p>",
+ "<p>The minimum percentage to accept while <code>adaptive</code> is working and not going lower than that.\nBe aware that the percentage calculation depends solely on the page structure, so don't play with this\nnumber unless you must know what you are doing!</p>": "<p>Der niedrigste erlaubte Prozentsatz für eine Übereinstimmung bei <code>adaptive</code>. Die Berechnung hängt nur von der Seitenstruktur ab. Ändern Sie diesen Wert nur, wenn Sie die Auswirkungen kennen.</p>",
+ "<p><code>Selectors</code> class.</p>": "<p>Die Klasse <code>Selectors</code>.</p>",
+ "<p>Search the current tree with XPath selectors</p>": "<p>Durchsucht den aktuellen Baum mit XPath-Selektoren.</p>",
+ "<p>Note: <strong>Additional keyword arguments will be passed as XPath variables in the XPath expression!</strong></p>": "<p>Hinweis: <strong>Zusätzliche Schlüsselwortargumente werden als XPath-Variablen an den XPath-Ausdruck übergeben!</strong></p>",
+ "<p>The XPath selector to be used.</p>": "<p>Der zu verwendende XPath-Selektor.</p>",
+ "<p>Find elements by filters of your creations for ease.</p>": "<p>Findet Elemente einfach mit selbst festgelegten Filtern.</p>",
+ "<p>Tag name(s), iterable of tag names, regex patterns, function, or a dictionary of elements' attributes. Leave empty for selecting all.</p>": "<p>Tag-Name, mehrere Tag-Namen, Iterable von Tag-Namen, Regex-Muster, Funktion oder Dictionary mit Elementattributen. Leer lassen, um alle auszuwählen.</p>",
+ "<p>The attributes you want to filter elements based on it.</p>": "<p>Attribute, nach denen die Elemente gefiltert werden sollen.</p>",
+ "<p>The <code>Selectors</code> object of the elements or empty list</p>": "<p>Das <code>Selectors</code>-Objekt der Elemente oder eine leere Liste.</p>",
+ "<p>Find elements by filters of your creations for ease, then return the first result. Otherwise return <code>None</code>.</p>": "<p>Findet Elemente mit selbst festgelegten Filtern und gibt den ersten Treffer zurück. Andernfalls wird <code>None</code> zurückgegeben.</p>",
+ "<p>The <code>Selector</code> object of the element or <code>None</code> if the result didn't match</p>": "<p>Das <code>Selector</code>-Objekt des Elements oder <code>None</code>, wenn kein Treffer gefunden wurde.</p>",
+ "<p>Saves the element's unique properties to the storage for retrieval and relocation later</p>": "<p>Speichert die eindeutigen Eigenschaften des Elements, um es später abzurufen und wiederzufinden.</p>",
+ "<p>The element itself that we want to save to storage, it can be a <code>Selector</code> or pure <code>HtmlElement</code></p>": "<p>Das zu speichernde Element. Es kann ein <code>Selector</code> oder ein reines <code>HtmlElement</code> sein.</p>",
+ "<p>This is the identifier that will be used to retrieve the element later from the storage. See\nthe docs for more info.</p>": "<p>Kennung, mit der das Element später aus dem Speicher abgerufen wird. Weitere Informationen finden Sie in der Dokumentation.</p>",
+ "<p>Using the identifier, we search the storage and return the unique properties of the element</p>": "<p>Durchsucht den Speicher anhand der Kennung und gibt die eindeutigen Eigenschaften des Elements zurück.</p>",
+ "<p>This is the identifier that will be used to retrieve the element from the storage. See\nthe docs for more info.</p>": "<p>Kennung zum Abrufen des Elements aus dem Speicher. Weitere Informationen finden Sie in der Dokumentation.</p>",
+ "<p>A dictionary of the unique properties</p>": "<p>Dictionary mit den eindeutigen Eigenschaften.</p>",
+ "<p>Return JSON response if the response is jsonable otherwise throws error</p>": "<p>Gibt die Antwort als JSON zurück, wenn sie sich entsprechend umwandeln lässt. Andernfalls wird ein Fehler ausgelöst.</p>",
+ "<p>Apply the given regex to the current text and return a list of strings with the matches.</p>": "<p>Wendet den angegebenen Regex auf den aktuellen Text an und gibt eine Liste von Strings mit den Treffern zurück.</p>",
+ "<p>Can be either a compiled regular expression or a string.</p>": "<p>Ein kompilierter regulärer Ausdruck oder ein String.</p>",
+ "<p>If enabled character entity references are replaced by their corresponding character</p>": "<p>Wenn aktiviert, werden Zeichenreferenzen durch die entsprechenden Zeichen ersetzt.</p>",
+ "<p>if enabled, this will ignore all whitespaces and consecutive spaces while matching</p>": "<p>Wenn aktiviert, wird Leerraum einschließlich aufeinanderfolgender Leerzeichen bei der Suche ignoriert.</p>",
+ "<p>if disabled, the function will set the regex to ignore the letters case while compiling it</p>": "<p>Wenn deaktiviert, wird der Regex so kompiliert, dass er Groß- und Kleinschreibung ignoriert.</p>",
+ "<p>Apply the given regex to text and return the first match if found, otherwise return the default value.</p>": "<p>Wendet den angegebenen Regex auf den Text an und gibt den ersten Treffer zurück. Ohne Treffer wird der Standardwert zurückgegeben.</p>",
+ "<p>The default value to be returned if there is no match</p>": "<p>Standardwert, der zurückgegeben wird, wenn kein Treffer vorliegt.</p>",
+ "<p>\n <span class=\"doc-param-default\">\n <b>DEFAULT:</b>\n <code>None</code>\n </span>\n </p>": "<p>\n <span class=\"doc-param-default\">\n <b>STANDARDWERT:</b>\n <code>None</code>\n </span>\n </p>",
+ "<p>if enabled character entity references are replaced by their corresponding character</p>": "<p>Wenn aktiviert, werden Zeichenreferenzen durch die entsprechenden Zeichen ersetzt.</p>",
+ "<p>Find elements that are in the same tree depth in the page with the same tag name and same parent tag etc...\nthen return the ones that match the current element attributes with a percentage higher than the input threshold.</p>": "<p>Findet Elemente auf derselben Tiefe im Seitenbaum mit demselben Tag-Namen, demselben Tag-Namen des Elternelements und weiteren gemeinsamen Merkmalen. Gibt dann diejenigen zurück, deren Attribute mit denen des aktuellen Elements über dem angegebenen Schwellenwert übereinstimmen.</p>",
+ "<p>This function is inspired by AutoScraper and made for cases where you, for example, found a product div inside\na products-list container and want to find other products using that element as a starting point EXCEPT\nthis function works in any case without depending on the element type.</p>": "<p>Diese Funktion wurde von AutoScraper inspiriert. Sie ist zum Beispiel hilfreich, wenn Sie ein Produkt-div in einer Produktliste gefunden haben und damit weitere Produkte suchen möchten. Sie funktioniert jedoch unabhängig vom Elementtyp.</p>",
+ "<p>The percentage to use while comparing element attributes.\nNote: Elements found before attributes matching/comparison will be sharing the same depth, same tag name,\nsame parent tag name, and same grand parent tag name. So they are 99% likely to be correct unless you are\nextremely unlucky, then attributes matching comes into play, so don't play with this number unless\nyou are getting the results you don't want.\nAlso, if the current element doesn't have attributes and the similar element as well, then it's a 100% match.</p>": "<p>Prozentsatz zum Vergleichen der Elementattribute. Schon vor diesem Vergleich haben die gefundenen Elemente dieselbe Tiefe, denselben Tag-Namen sowie dieselben Tag-Namen ihrer Eltern- und Großelternelemente. Daher sind sie mit 99 % Wahrscheinlichkeit bereits richtig, sofern Sie nicht besonders viel Pech haben. Erst danach werden die Attribute verglichen. Ändern Sie den Wert nur, wenn Sie unerwünschte Ergebnisse erhalten. Haben weder das aktuelle noch das ähnliche Element Attribute, gilt das als Übereinstimmung von 100 %.</p>",
+ "<p>Attribute names passed will be ignored while matching the attributes in the last step.\nThe default value is to ignore <code>href</code> and <code>src</code> as URLs can change a lot between elements, so it's unreliable</p>": "<p>Die angegebenen Attributnamen werden beim letzten Vergleichsschritt ignoriert. Standardmäßig werden <code>href</code> und <code>src</code> ignoriert, da URLs zwischen Elementen stark abweichen können und daher unzuverlässig sind.</p>",
+ "<p>If True, element text content will be taken into calculation while matching.\nNot recommended to use in normal cases, but it depends.</p>": "<p>Wenn True, wird der Textinhalt beim Vergleich berücksichtigt. Für gewöhnliche Fälle nicht empfohlen, kann aber je nach Fall nützlich sein.</p>",
+ "<p>A <code>Selectors</code> container of <code>Selector</code> objects or empty list</p>": "<p>Ein <code>Selectors</code>-Container mit <code>Selector</code>-Objekten oder eine leere Liste.</p>",
+ "<p>Find elements that its text content fully/partially matches input.</p>": "<p>Findet Elemente, deren Textinhalt ganz oder teilweise mit der Eingabe übereinstimmt.</p>",
+ "<p>Text query to match</p>": "<p>Text, nach dem gesucht werden soll.</p>",
+ "<p>Returns the first element that matches conditions, enabled by default</p>": "<p>Gibt das erste Element zurück, das die Bedingungen erfüllt. Standardmäßig aktiviert.</p>",
+ "<p>If enabled, the function returns elements that contain the input text</p>": "<p>Wenn aktiviert, gibt die Funktion Elemente zurück, die den eingegebenen Text enthalten.</p>",
+ "<p>if enabled, the letters case will be taken into consideration</p>": "<p>Berücksichtigt die Groß- und Kleinschreibung, wenn aktiviert.</p>",
+ "<p>Find elements that its text content matches the input regex pattern.</p>": "<p>Sucht Elemente, deren Text zum angegebenen Regex-Muster passt.</p>",
+ "<p>Regex query/pattern to match</p>": "<p>Regex-Muster für die Suche.</p>",
+ "<p>Return the first element that matches conditions; enabled by default.</p>": "<p>Gibt das erste Element zurück, das die Bedingungen erfüllt. Standardmäßig aktiviert.</p>",
+ "<p>If enabled, the letters case will be taken into consideration in the regex.</p>": "<p>Berücksichtigt die Groß- und Kleinschreibung in der Regex, wenn aktiviert.</p>",
+ "<p>If enabled, this will ignore all whitespaces and consecutive spaces while matching.</p>": "<p>Ignoriert bei der Suche alle Leerraumzeichen und aufeinanderfolgenden Leerzeichen, wenn aktiviert.</p>",
+ "<p>A basic <code>Fetcher</code> class type that can only do basic GET, POST, PUT, and DELETE HTTP requests based on <code>curl_cffi</code>.</p>": "<p>Einfache <code>Fetcher</code>-Klasse für HTTP-Anfragen mit GET, POST, PUT und DELETE über <code>curl_cffi</code>.</p>",
+ "<p>Set multiple arguments for the parser at once globally</p>": "<p>Legt mehrere Parser-Argumente gleichzeitig und global fest.</p>",
+ "<p>The keywords can be any arguments of the following: huge_tree, keep_comments, adaptive, storage, storage_args, adaptive_domain</p>": "<p>Mögliche Argumente sind huge_tree, keep_comments, adaptive, storage, storage_args und adaptive_domain.</p>",
+ "<p>\n <span class=\"doc-param-default\">\n <b>DEFAULT:</b>\n <code>{}</code>\n </span>\n </p>": "<p>\n <span class=\"doc-param-default\">\n <b>STANDARDWERT:</b>\n <code>{}</code>\n </span>\n </p>",
+ "<p>A <code>Fetcher</code> class type which is a completely stealthy built on top of Chromium.</p>": "<p>Vollständig getarnte <code>Fetcher</code>-Klasse auf Basis von Chromium.</p>",
+ "<p>It works as real browsers passing almost all online tests/protections with many customization options.</p>": "<p>Verhält sich wie ein echter Browser, besteht fast alle Online-Tests und Schutzprüfungen und bietet viele Einstellungsmöglichkeiten.</p>",
+ "<p>Opens up a browser and do your request based on your chosen options below.</p>": "<p>Öffnet einen Browser und führt die Anfrage mit den unten gewählten Optionen aus.</p>",
+ "<p>Target url.</p>": "<p>Ziel-URL.</p>",
+ "<p>Run the browser in headless/hidden (default), or headful/visible mode.</p>": "<p>Startet den Browser ohne sichtbares Fenster, was der Standard ist, oder mit sichtbarem Fenster.</p>",
+ "<p>Drop requests for unnecessary resources for a speed boost.\nRequests dropped are of type <code>font</code>, <code>image</code>, <code>media</code>, <code>beacon</code>, <code>object</code>, <code>imageset</code>, <code>texttrack</code>, <code>websocket</code>, <code>csp_report</code>, and <code>stylesheet</code>.</p>": "<p>Blockiert unnötige Ressourcen, um das Laden zu beschleunigen. Betroffen sind die Typen <code>font</code>, <code>image</code>, <code>media</code>, <code>beacon</code>, <code>object</code>, <code>imageset</code>, <code>texttrack</code>, <code>websocket</code>, <code>csp_report</code> und <code>stylesheet</code>.</p>",
+ "<p>A set of domain names to block requests to. Subdomains are also matched (e.g., <code>\"example.com\"</code> blocks <code>\"sub.example.com\"</code> too).</p>": "<p>Menge von Domains, an die keine Anfragen gesendet werden. Auch Subdomains werden erfasst: <code>\"example.com\"</code> blockiert zum Beispiel <code>\"sub.example.com\"</code>.</p>",
+ "<p>Block requests to ~3,500 known ad/tracking domains. Can be combined with <code>blocked_domains</code>.</p>": "<p>Blockiert Anfragen an etwa 3.500 bekannte Werbe- und Tracking-Domains. Kann mit <code>blocked_domains</code> kombiniert werden.</p>",
+ "<p>Route DNS queries through Cloudflare's DNS-over-HTTPS to prevent DNS leaks when using proxies.</p>": "<p>Leitet DNS-Anfragen über Cloudflares DNS-over-HTTPS, um DNS-Lecks bei der Proxy-Nutzung zu verhindern.</p>",
+ "<p>Pass a useragent string to be used. Otherwise the fetcher will generate a real Useragent of the same browser and use it.</p>": "<p>Zu verwendende User-Agent-Zeichenkette. Ohne Angabe erzeugt und verwendet der Fetcher einen echten User-Agent desselben Browsers.</p>",
+ "<p>Set cookies for the next request.</p>": "<p>Cookies für die nächste Anfrage.</p>",
+ "<p>Wait for the page until there are no network connections for at least 500 ms.</p>": "<p>Wartet, bis die Seite mindestens 500 ms lang keine Netzwerkverbindungen mehr hat.</p>",
+ "<p>The timeout in milliseconds that is used in all operations and waits through the page. The default is 30,000</p>": "<p>Maximale Wartezeit in Millisekunden für alle Operationen und Wartevorgänge auf der Seite. Der Standardwert ist 30.000.</p>",
+ "<p>The time (milliseconds) the fetcher will wait after everything finishes before closing the page and returning the <code>Response</code> object.</p>": "<p>Zusätzliche Wartezeit in Millisekunden nach Abschluss aller Schritte, bevor der Fetcher die Seite schließt und das <code>Response</code>-Objekt zurückgibt.</p>",
+ "<p>Added for automation. A function that takes the <code>page</code> object, runs after navigation, and does the automation you need.</p>": "<p>Funktion zur Automatisierung. Sie erhält das <code>page</code>-Objekt und führt nach der Navigation die gewünschten Aktionen aus.</p>",
+ "<p>A function that takes the <code>page</code> object, runs before navigation. Use it to register event listeners or routes that must be set up before the page loads.</p>": "<p>Funktion, die das <code>page</code>-Objekt erhält und vor der Navigation läuft. Registrieren Sie damit Event-Listener oder Routen, die vor dem Laden der Seite bereitstehen müssen.</p>",
+ "<p>Wait for a specific CSS selector to be in a specific state.</p>": "<p>Wartet, bis ein bestimmter CSS-Selektor den angegebenen Zustand erreicht.</p>",
+ "<p>An absolute path to a JavaScript file to be executed on page creation for all pages in this session.</p>": "<p>Absoluter Pfad einer JavaScript-Datei, die beim Erstellen jeder Seite dieser Sitzung ausgeführt wird.</p>",
+ "<p>Specify user locale, for example, <code>en-GB</code>, <code>de-DE</code>, etc. Locale will affect navigator.language value, Accept-Language request header value as well as number and date formatting\nrules. Defaults to the system default locale.</p>": "<p>Regionale Einstellungen, etwa <code>en-GB</code> oder <code>de-DE</code>. Sie beeinflussen navigator.language, den Anfrage-Header Accept-Language sowie Zahlen- und Datumsformate. Standardmäßig werden die Systemeinstellungen verwendet.</p>",
+ "<p>Changes the timezone of the browser. Defaults to the system timezone.</p>": "<p>Ändert die Zeitzone des Browsers. Standardwert ist die Zeitzone des Systems.</p>",
+ "<p>The state to wait for the selector given with <code>wait_selector</code>. The default state is <code>attached</code>.</p>": "<p>Zustand, auf den für den mit <code>wait_selector</code> angegebenen Selektor gewartet wird. Der Standardwert ist <code>attached</code>.</p>",
+ "<p>Solves all types of the Cloudflare's Turnstile/Interstitial challenges before returning the response to you.</p>": "<p>Löst alle Arten von Cloudflare-Turnstile- und Interstitial-Prüfungen, bevor die Antwort zurückgegeben wird.</p>",
+ "<p>If you have a Chrome browser installed on your device, enable this, and the Fetcher will launch an instance of your browser and use it.</p>": "<p>Aktivieren Sie diese Option, wenn Chrome auf Ihrem Gerät installiert ist. Der Fetcher startet und verwendet dann eine Instanz dieses Browsers.</p>",
+ "<p>Add random noise to canvas operations to prevent fingerprinting.</p>": "<p>Ergänzt zufälliges Rauschen bei Canvas-Operationen, um Fingerprinting zu verhindern.</p>",
+ "<p>Forces WebRTC to respect proxy settings to prevent local IP address leak.</p>": "<p>Zwingt WebRTC, die Proxy-Einstellungen zu beachten, um die lokale IP-Adresse nicht offenzulegen.</p>",
+ "<p>Enabled by default. Disabling it disables WebGL and WebGL 2.0 support entirely. Disabling WebGL is not recommended as many WAFs now check if WebGL is enabled.</p>": "<p>Standardmäßig aktiviert. Beim Deaktivieren werden WebGL und WebGL 2.0 vollständig abgeschaltet. Das wird nicht empfohlen, weil viele WAFs prüfen, ob WebGL aktiv ist.</p>",
+ "<p>Enabled by default, wait for all JavaScript on page(s) to fully load and execute.</p>": "<p>Wartet, bis das gesamte JavaScript der Seiten geladen und ausgeführt wurde. Standardmäßig aktiviert.</p>",
+ "<p>Include open Shadow DOM content in the response HTML. Defaults to False.</p>": "<p>Nimmt offene Shadow-DOM-Inhalte in das HTML der Antwort auf. Der Standardwert ist False.</p>",
+ "<p>Instead of launching a new browser instance, connect to this CDP URL to control real browsers through CDP.</p>": "<p>Verbindet sich mit dieser CDP-URL, um einen bestehenden Browser über CDP zu steuern, statt eine neue Instanz zu starten.</p>",
+ "<p>Enabled by default, Scrapling will set a Google referer header.</p>": "<p>Standardmäßig aktiviert. Scrapling setzt einen Google-Referer-Header.</p>",
+ "<p>A dictionary of extra headers to add to the request. <em>The referer set by <code>google_search</code> takes priority over the referer set here if used together.</em></p>": "<p>Dictionary mit zusätzlichen Headern für die Anfrage. <em>Der Referer aus <code>google_search</code> hat Vorrang vor dem hier gesetzten Referer, wenn Sie beide verwenden.</em></p>",
+ "<p>The proxy to be used with requests, it can be a string or a dictionary with the keys 'server', 'username', and 'password' only.</p>": "<p>Proxy für die Anfragen. Möglich sind eine Zeichenkette oder ein Dictionary mit ausschließlich den Schlüsseln 'server', 'username' und 'password'.</p>",
+ "<p>Path to a User Data Directory, which stores browser session data like cookies and local storage. The default is to create a temporary directory.</p>": "<p>Pfad zum Benutzerprofilordner mit Browser-Sitzungsdaten wie Cookies und lokalem Speicher. Standardmäßig wird ein temporärer Ordner erstellt.</p>",
+ "<p>A list of additional browser flags to pass to the browser on launch.</p>": "<p>Liste zusätzlicher Browser-Optionen für den Start.</p>",
+ "<p>The arguments that will be passed in the end while creating the final Selector's class.</p>": "<p>Argumente zum Erstellen des endgültigen Selector-Objekts.</p>",
+ "<p>Additional arguments to be passed to Playwright's context as additional settings, and it takes higher priority than Scrapling's settings.</p>": "<p>Zusätzliche Einstellungen für den Playwright-Kontext. Sie haben Vorrang vor den Scrapling-Einstellungen.</p>",
+ "<p>A <code>Response</code> object.</p>": "<p>Ein <code>Response</code>-Objekt.</p>",
+ "<p>A factory context manager that provides configured Fetcher sessions.</p>": "<p>Kontextmanager, der konfigurierte Fetcher-Sitzungen erstellt.</p>",
+ "<p>When this manager is used in a 'with' or 'async with' block,\nit yields a new session configured with the manager's defaults.\nA single instance of this manager should ideally be used for one active\nsession at a time (or sequentially). Re-entering a context with the\nsame manager instance while a session is already active is disallowed.</p>": "<p>In einem 'with'- oder 'async with'-Block liefert dieser Kontextmanager eine neue Sitzung mit seinen Standardwerten. Nutzen Sie eine Instanz möglichst für nur eine aktive Sitzung gleichzeitig oder für mehrere Sitzungen nacheinander. Sie können mit derselben Instanz keinen weiteren Kontext öffnen, solange eine Sitzung aktiv ist.</p>",
+ "<p>Browser version to impersonate. Can be a single browser string or a list of browser strings for random selection. (Default: latest available Chrome version)</p>": "<p>Zu imitierende Browserversion. Möglich sind eine einzelne Browser-Zeichenkette oder eine Liste zur zufälligen Auswahl. Standardwert ist die neueste verfügbare Chrome-Version.</p>",
+ "<p>Whether to use HTTP3. Defaults to False. It might be problematic if used it with <code>impersonate</code>.</p>": "<p>Legt fest, ob HTTP3 verwendet wird. Der Standardwert ist False. Zusammen mit <code>impersonate</code> kann dies Probleme verursachen.</p>",
+ "<p>If enabled (default), it creates and adds real browser headers. It also sets a Google referer header.</p>": "<p>Erzeugt und ergänzt echte Browser-Header, einschließlich eines Google-Referer-Headers. Standardmäßig aktiviert.</p>",
+ "<p>Dict of proxies to use. Format: {\"http\": proxy_url, \"https\": proxy_url}.</p>": "<p>Dictionary mit den zu verwendenden Proxys. Format: {\"http\": proxy_url, \"https\": proxy_url}.</p>",
+ "<p>Proxy URL to use. Format: \"http://username:password@localhost:8030\".\nCannot be used together with the <code>proxies</code> parameter.</p>": "<p>Zu verwendende Proxy-URL. Format: \"http://username:password@localhost:8030\". Kann nicht mit dem Parameter <code>proxies</code> kombiniert werden.</p>",
+ "<p>HTTP basic auth for proxy, tuple of (username, password).</p>": "<p>HTTP-Basic-Authentifizierung für den Proxy als Tupel (username, password).</p>",
+ "<p>Number of seconds to wait before timing out.</p>": "<p>Maximale Wartezeit in Sekunden.</p>",
+ "<p>Headers to include in the session with every request.</p>": "<p>Header, die bei jeder Anfrage der Sitzung mitgesendet werden.</p>",
+ "<p>Number of retry attempts. Defaults to 3.</p>": "<p>Anzahl erneuter Versuche. Der Standardwert ist 3.</p>",
+ "<p>Number of seconds to wait between retry attempts. Defaults to 1 second.</p>": "<p>Wartezeit in Sekunden zwischen erneuten Versuchen. Der Standardwert ist 1 Sekunde.</p>",
+ "<p>Whether to follow redirects. Defaults to \"safe\", which follows redirects but rejects those targeting internal/private IPs (SSRF protection). Pass True to follow all redirects without restriction.</p>": "<p>Legt fest, ob Weiterleitungen gefolgt wird. Der Standardwert \"safe\" folgt Weiterleitungen, lehnt aber Ziele mit internen oder privaten IP-Adressen ab. Das schützt vor SSRF. Mit True folgen Sie allen Weiterleitungen ohne Einschränkung.</p>",
+ "<p>Maximum number of redirects. Default 30, use -1 for unlimited.</p>": "<p>Maximale Anzahl der Weiterleitungen. Der Standardwert ist 30. Mit -1 gibt es keine Begrenzung.</p>",
+ "<p>Whether to verify HTTPS certificates. Defaults to True.</p>": "<p>Legt fest, ob HTTPS-Zertifikate geprüft werden. Der Standardwert ist True.</p>",
+ "<p>Tuple of (cert, key) filenames for the client certificate.</p>": "<p>Tupel (cert, key) mit den Dateinamen des Client-Zertifikats und seines Schlüssels.</p>",
+ "<p>Arguments passed when creating the final Selector class.</p>": "<p>Argumente zum Erstellen des endgültigen Selector-Objekts.</p>",
+ "<p>A ProxyRotator instance for automatic proxy rotation.</p>": "<p>Eine ProxyRotator-Instanz für den automatischen Proxy-Wechsel.</p>",
+ "<p>Creates and returns a new synchronous Fetcher Session</p>": "<p>Erstellt eine neue synchrone Fetcher-Sitzung und gibt sie zurück.</p>",
+ "<p>Creates and returns a new asynchronous Session.</p>": "<p>Erstellt eine neue asynchrone Sitzung und gibt sie zurück.</p>",
+ "<p>A Stealthy Browser session manager with page pooling.</p>": "<p>Verwaltet getarnte Browser-Sitzungen mit einem Pool wiederverwendbarer Seiten.</p>",
+ "<p>A Browser session manager with page pooling, it's using a persistent browser Context by default with a temporary user profile directory.</p>": "<p>Verwaltet Browser-Sitzungen mit einem Pool wiederverwendbarer Seiten. Verwendet standardmäßig einen dauerhaften Browser-Kontext mit einem temporären Benutzerprofilordner.</p>",
+ "<p>Save completed browser requests and responses. Failed or unfinished requests are omitted. Defaults to False.</p>": "<p>Speichert abgeschlossene Browser-Anfragen und Antworten. Fehlgeschlagene und noch laufende Anfragen werden weggelassen. Der Standardwert ist False.</p>",
+ "<p>Maximum retained requests per session. Defaults to 1000; older entries are removed.</p>": "<p>Maximale Anzahl gespeicherter Anfragen pro Sitzung. Der Standardwert ist 1.000. Ältere Einträge werden entfernt.</p>",
+ "<p>Save cookies, local storage and IndexedDB to a Playwright-compatible JSON file.</p>": "<p>Speichert Cookies, lokalen Speicher und IndexedDB in einer mit Playwright kompatiblen JSON-Datei.</p>",
+ "<p>Requires a started session without proxy rotation. Does not save sessionStorage.</p>": "<p>Erfordert eine gestartete Sitzung ohne Proxy-Wechsel. sessionStorage wird nicht gespeichert.</p>",
+ "<p>Replace cookies, local storage and IndexedDB from a Playwright-compatible JSON file.</p>": "<p>Ersetzt Cookies, lokalen Speicher und IndexedDB durch die Daten aus einer mit Playwright kompatiblen JSON-Datei.</p>",
+ "<p>Requires a started session without proxy rotation. Fetch or reload pages to use the restored login.</p>": "<p>Erfordert eine gestartete Sitzung ohne Proxy-Wechsel. Rufen Sie Seiten ab oder laden Sie sie neu, um die wiederhergestellte Anmeldung zu nutzen.</p>",
+ "<p>Close every open tab in the session's pool. The next request opens a fresh tab.</p>": "<p>Schließt alle offenen Tabs im Pool der Sitzung. Die nächste Anfrage öffnet einen neuen Tab.</p>",
+ "<p>Close all resources</p>": "<p>Schließt alle Ressourcen.</p>",
+ "<p>Get statistics about the current page pool</p>": "<p>Liefert Statistiken zum aktuellen Seiten-Pool.</p>",
+ "<p>Create a browser for this instance and context.</p>": "<p>Erstellt einen Browser für diese Instanz und ihren Kontext.</p>",
+ "<p>Opens up the browser and do your request based on your chosen options.</p>": "<p>Öffnet den Browser und führt die Anfrage mit den gewählten Optionen aus.</p>",
+ "<p>The Target url.</p>": "<p>Ziel-URL.</p>",
+ "<p>Static proxy to override rotator and session proxy. A new browser context will be created and used with it.</p>": "<p>Fester Proxy, der den Rotator und den Proxy der Sitzung überschreibt. Für ihn wird ein neuer Browser-Kontext erstellt und verwendet.</p>",
+ "<p>An async Stealthy Browser session manager with page pooling.</p>": "<p>Verwaltet asynchrone, getarnte Browser-Sitzungen mit einem Pool wiederverwendbarer Seiten.</p>",
+ "<p>A thread-safe proxy rotator with pluggable rotation strategies.</p>": "<p>Proxy-Rotator, der sicher aus mehreren Threads genutzt werden kann und austauschbare Wechselstrategien bietet.</p>",
+ "<p>Supports:\n- Cyclic rotation (default)\n- Custom rotation strategies via callable\n- Both string URLs and Playwright-style dict proxies</p>": "<p>Unterstützt zyklischen Wechsel als Standard, eigene Strategien über aufrufbare Objekte sowie Proxys als URL-Zeichenketten oder Dictionarys im Playwright-Format.</p>",
+ "<p>Initialize the proxy rotator.</p>": "<p>Initialisiert den Proxy-Rotator.</p>",
+ "<p>List of proxy URLs or Playwright-style proxy dicts.\n- String format: \"http://proxy1:8080\" or \"http://user:pass@proxy:8080\"\n- Dict format: {\"server\": \"http://proxy:8080\", \"username\": \"user\", \"password\": \"pass\"}</p>": "<p>Liste von Proxy-URLs oder Proxy-Dictionarys im Playwright-Format. Zeichenkettenformat: \"http://proxy1:8080\" oder \"http://user:pass@proxy:8080\". Dictionary-Format: {\"server\": \"http://proxy:8080\", \"username\": \"user\", \"password\": \"pass\"}.</p>",
+ "<p>Rotation strategy function. Takes (proxies, current_index) and returns (proxy, next_index). Defaults to cyclic_rotation.</p>": "<p>Funktion für die Wechselstrategie. Nimmt (proxies, current_index) an und gibt (proxy, next_index) zurück. Der Standardwert ist cyclic_rotation.</p>",
+ "<p>Get a copy of all configured proxies.</p>": "<p>Liefert eine Kopie aller konfigurierten Proxys.</p>",
+ "<p>Get the next proxy according to the rotation strategy.</p>": "<p>Liefert den nächsten Proxy nach der gewählten Wechselstrategie.</p>",
+ "<p>Return the total number of configured proxies.</p>": "<p>Gibt die Gesamtzahl der konfigurierten Proxys zurück.</p>",
+ "<p>Extends standard Python string by adding more functionality</p>": "<p>Erweitert normale Python-Zeichenketten um weitere Funktionen.</p>",
+ "<p>Return a sorted version of the string</p>": "<p>Gibt eine sortierte Version der Zeichenkette zurück.</p>",
+ "<p>Return a new version of the string after removing all white spaces and consecutive spaces</p>": "<p>Gibt eine neue Version der Zeichenkette ohne Leerraumzeichen und aufeinanderfolgende Leerzeichen zurück.</p>",
+ "<p>Return JSON response if the response is jsonable otherwise throw error</p>": "<p>Liest die Antwort als JSON, wenn dies möglich ist. Sonst wird ein Fehler ausgelöst.</p>",
+ "<p>If enabled, this will ignore all whitespaces and consecutive spaces while matching</p>": "<p>Ignoriert bei der Suche alle Leerraumzeichen und aufeinanderfolgenden Leerzeichen, wenn aktiviert.</p>",
+ "<p>If disabled, function will set the regex to ignore the letters-case while compiling it</p>": "<p>Wenn deaktiviert, wird die Regex so kompiliert, dass Groß- und Kleinschreibung ignoriert wird.</p>",
+ "<p>Used to quickly check if this regex matches or not without any operations on the results</p>": "<p>Prüft schnell, ob die Regex einen Treffer findet, ohne die Ergebnisse weiter zu verarbeiten.</p>",
+ "<p>The :class:<code>TextHandlers</code> class is a subclass of the builtin <code>List</code> class, which provides a few additional methods.</p>": "<p>Die Klasse :class:<code>TextHandlers</code> erbt von der eingebauten Klasse <code>List</code> und bietet einige zusätzliche Methoden.</p>",
+ "<p>Call the <code>.re()</code> method for each element in this list and return\ntheir results flattened as TextHandlers.</p>": "<p>Ruft <code>.re()</code> für jedes Element dieser Liste auf und gibt die zusammengeführten Ergebnisse ohne verschachtelte Listen als TextHandlers zurück.</p>",
+ "<p>if disabled, the function will set the regex to ignore the letters-case while compiling it</p>": "<p>Wenn deaktiviert, wird die Regex so kompiliert, dass Groß- und Kleinschreibung ignoriert wird.</p>",
+ "<p>Call the <code>.re_first()</code> method for each element in this list and return\nthe first result or the default value otherwise.</p>": "<p>Ruft <code>.re_first()</code> für jedes Element dieser Liste auf und gibt den ersten Treffer zurück. Gibt es keinen, wird der Standardwert zurückgegeben.</p>",
+ "<p>Returns the first item of the current list</p>": "<p>Gibt das erste Element der aktuellen Liste zurück.</p>",
+ "<p>the default value to return if the current list is empty</p>": "<p>Wert, der bei einer leeren Liste zurückgegeben wird.</p>",
+ "<p>A read-only mapping to use instead of the standard dictionary for the speed boost, but at the same time I use it to add more functionalities.\nIf the standard dictionary is needed, convert this class to a dictionary with the <code>dict</code> function</p>": "<p>Schreibgeschützte Zuordnung, die normale Dictionarys für mehr Geschwindigkeit ersetzt und weitere Funktionen bietet. Wenn Sie ein normales Dictionary brauchen, wandeln Sie sie mit <code>dict</code> um.</p>",
+ "<p>Convert current attributes to JSON bytes if the attributes are JSON serializable otherwise throws error</p>": "<p>Wandelt die aktuellen Attribute in JSON-Bytes um, wenn sie sich als JSON serialisieren lassen. Sonst wird ein Fehler ausgelöst.</p>",
+ "<p>Acts like the standard dictionary <code>.get()</code> method</p>": "<p>Funktioniert wie die Methode <code>.get()</code> eines normalen Dictionarys.</p>",
+ "<p>Search current attributes by values and return a dictionary of each matching item</p>": "<p>Durchsucht die aktuellen Attributwerte und liefert für jeden Treffer ein Dictionary.</p>",
+ "<p>The keyword to search for in the attribute values</p>": "<p>Text, nach dem in den Attributwerten gesucht wird.</p>",
+ "<p>If True, the function will search if keyword in each value instead of perfect match</p>": "<p>Bei True wird geprüft, ob jeder Wert den gesuchten Text enthält. Eine exakte Übereinstimmung ist dann nicht nötig.</p>",
+ "<p>Request's response information structure.</p>": "<p>Datenstruktur mit den Antwortinformationen einer Anfrage.</p>",
+ "<p><code>browser_network_requests</code> returns <code>NetworkRequestsModel</code> with <code>requests</code>, <code>next_cursor</code>, <code>has_more</code>, and <code>dropped_count</code>. Each <code>NetworkRequestInfo</code> contains <code>id</code>, <code>url</code>, <code>method</code>, <code>resource_type</code>, and <code>status</code>. Pass <code>next_cursor</code> as <code>after_id</code> to continue; <code>has_more</code> indicates more current matches.</p>": "<p><code>browser_network_requests</code> gibt ein <code>NetworkRequestsModel</code> mit <code>requests</code>, <code>next_cursor</code>, <code>has_more</code> und <code>dropped_count</code> zurück. Jedes <code>NetworkRequestInfo</code> enthält <code>id</code>, <code>url</code>, <code>method</code>, <code>resource_type</code> und <code>status</code>. Übergeben Sie <code>next_cursor</code> als <code>after_id</code>, um fortzufahren. <code>has_more</code> zeigt an, ob es aktuell weitere Treffer gibt.</p>",
+ "<p><code>browser_network_request</code> returns <code>NetworkRequestModel</code> with <code>request_id</code>, <code>part</code>, <code>data</code>, and <code>note</code>. Summaries and headers are objects; the full saved body text is returned as a string, including JSON response text. <code>note</code> explains missing body data or partial headers.</p>": "<p><code>browser_network_request</code> gibt ein <code>NetworkRequestModel</code> mit <code>request_id</code>, <code>part</code>, <code>data</code> und <code>note</code> zurück. Zusammenfassungen und Header sind Objekte. Der vollständige gespeicherte Antwortinhalt wird als Zeichenkette zurückgegeben, auch bei JSON-Antworten. <code>note</code> erklärt fehlende Antwortinhalte oder unvollständige Header.</p>",
+ "<p>Summary of a recorded browser request.</p>": "<p>Zusammenfassung einer aufgezeichneten Browser-Anfrage.</p>",
+ "<p>Recorded request summaries and pagination details.</p>": "<p>Zusammenfassungen aufgezeichneter Anfragen mit Angaben zum seitenweisen Abruf.</p>",
+ "<p>One complete saved request part, with an optional note.</p>": "<p>Ein vollständiger gespeicherter Teil einer Anfrage mit einem optionalen Hinweis.</p>",
+ "<p>Model classes for session management:</p>": "<p>Modellklassen für die Sitzungsverwaltung:</p>",
+ "<p>Information about an open browser session.</p>": "<p>Informationen über eine offene Browser-Sitzung.</p>",
+ "<p>Response returned when a new session is created.</p>": "<p>Antwort beim Erstellen einer neuen Sitzung.</p>",
+ "<p>Response returned when a session is closed.</p>": "<p>Antwort beim Schließen einer Sitzung.</p>",
+ "<p>The main MCP server class that provides all web scraping tools:</p>": "<p>Die Hauptklasse des MCP-Servers, die alle Web-Scraping-Werkzeuge bereitstellt:</p>",
+ "<p><strong><code>browser_fetch_once</code></strong>: Fetch one URL through a stealthy browser with JavaScript rendering and Cloudflare handling, then close the browser. Use a persistent session for later actions or network history.</p>": "<p><strong><code>browser_fetch_once</code></strong>: Ruft eine URL mit einem Stealthy-Browser ab, führt JavaScript aus, bewältigt Cloudflare-Prüfungen und schließt danach den Browser. Nutzen Sie für spätere Aktionen oder den Netzwerkverlauf eine dauerhafte Sitzung.</p>",
+ "<p><strong><code>browser_extract</code></strong>: Read the current page or one element as an AI snapshot, HTML, Markdown, or text without reloading it. Keep results from forms and page actions. Snapshots include element roles, names, references, positions, and sizes; regex search returns matching lines with nearby context and parent nodes.</p>": "<p><strong><code>browser_extract</code></strong>: Liest die aktuelle Seite oder ein Element als strukturierte Ansicht für die KI, HTML, Markdown oder Text, ohne neu zu laden. Behält Ergebnisse von Formularen und Browser-Aktionen bei. Die Ansichten enthalten Rollen, Namen, Referenzen, Positionen und Größen der Elemente. Eine Regex-Suche gibt passende Zeilen mit nahem Kontext und übergeordneten Knoten zurück.</p>",
+ "<p><strong><code>browser_actions</code></strong>: Chain mouse moves, hovers, clicks, scrolling, field filling, keyboard shortcuts, dialog replies, and waits in one call. Accept or dismiss alerts and confirmations, or enter text in prompts. Fill a search box, submit it, wait for results, and open a result without a separate call for each step.</p>": "<p><strong><code>browser_actions</code></strong>: Verbindet Mausbewegungen, Überfahren, Klicks, Scrollen, das Ausfüllen von Feldern, Tastenkürzel, Dialogantworten und Wartebedingungen in einem Aufruf. Nimmt Meldungen und Bestätigungen an, schließt sie oder schreibt Text in Eingabedialoge. Füllt ein Suchfeld aus, sendet es ab, wartet auf Ergebnisse und öffnet ein Ergebnis, ohne jeden Schritt einzeln aufzurufen.</p>",
+ "<p>Moves and clicks target selectors, snapshot references, or coordinates; element targets wait and scroll into view. Supports movement in multiple steps, left, right, and middle clicks, double-clicks, and scrolling nested panels.</p>": "<p>Bewegungen und Klicks verwenden Selektoren, Referenzen aus der Seitenansicht oder Koordinaten. Bei Zielelementen wird gewartet und ins Blickfeld gescrollt. Unterstützt Bewegungen in mehreren Schritten, Links-, Rechts- und Mittelklicks, Doppelklicks und das Scrollen verschachtelter Bereiche.</p>",
+ "<p>Target fields anywhere on the page through selectors or snapshot references. Fill text, check or uncheck boxes, select radio buttons, and choose one or more native dropdown options by label. Replace or clear text, or type at the current caret. Keyboard shortcuts use the current focus. Slow mode adds random pauses between typed characters and all actions.</p>": "<p>Wählen Sie Felder überall auf der Seite mit Selektoren oder Referenzen aus. Geben Sie Text ein, aktivieren oder deaktivieren Sie Kontrollkästchen, wählen Sie Optionsfelder und eine oder mehrere native Dropdown-Optionen anhand ihrer Beschriftung. Ersetzen oder löschen Sie Text oder tippen Sie an der aktuellen Cursorposition. Tastenkürzel verwenden den aktuellen Fokus. Der langsame Modus fügt zufällige Pausen zwischen eingegebenen Zeichen und allen Aktionen ein.</p>",
+ "<p>Wait for content or loading overlays through selectors or snapshot references, wait for page load events or settled network activity, or add a fixed pause before continuing.</p>": "<p>Warten Sie mit Selektoren oder Referenzen aus der Seitenansicht auf Inhalte oder Ladeanzeigen. Warten Sie auf Seitenladeereignisse oder darauf, dass die Netzwerkaktivität zur Ruhe kommt. Sie können vor dem Fortfahren auch eine feste Pause einfügen.</p>",
+ "<p><strong><code>browser_evaluate</code></strong>: Run JavaScript on the current page to extract custom data, calculate results, read application state, or update page content. Supports asynchronous scripts and returns their results as JSON.</p>": "<p><strong><code>browser_evaluate</code></strong>: Führt JavaScript auf der aktuellen Seite aus, um eigene Daten zu extrahieren, Ergebnisse zu berechnen, den Anwendungszustand zu lesen oder Seiteninhalte zu ändern. Unterstützt asynchrone Skripte und gibt ihre Ergebnisse als JSON zurück.</p>",
+ "<p>Create a Scrapling MCP server.</p>": "<p>Erstellt einen Scrapling-MCP-Server.</p>",
+ "<p>Optional global Chromium-compatible browser executable path for browser tools.\nIf omitted, the SCRAPLING_EXECUTABLE_PATH environment variable is used when set.</p>": "<p>Optionaler globaler Pfad zu einer ausführbaren Browser-Datei, die mit Chromium kompatibel ist, für die Browser-Werkzeuge. Ohne Angabe wird die Umgebungsvariable SCRAPLING_EXECUTABLE_PATH verwendet, falls sie gesetzt ist.</p>",
+ "<p>Optional shared token that clients must send as <code>Authorization: Bearer &lt;token&gt;</code>.\nIf omitted, the SCRAPLING_MCP_AUTH_TOKEN environment variable is used when set. It only applies\nto the streamable-http transport.</p>": "<p>Optionales gemeinsames Token, das Clients als <code>Authorization: Bearer &lt;token&gt;</code> senden müssen. Ohne Angabe wird die Umgebungsvariable SCRAPLING_MCP_AUTH_TOKEN verwendet, falls sie gesetzt ist. Gilt nur für den Transport streamable-http.</p>",
+ "<p>Open a reusable stealthy browser session. Pass per-request options to <code>browser_fetch</code>.</p>": "<p>Öffnet eine wiederverwendbare Stealthy-Browser-Sitzung. Übergeben Sie Optionen einzelner Anfragen an <code>browser_fetch</code>.</p>",
+ "<p>Save browser cookies, local storage and IndexedDB as Playwright-compatible JSON. Excludes sessionStorage.</p>": "<p>Speichert Browser-Cookies, Local Storage und IndexedDB als JSON, das mit Playwright kompatibel ist. Enthält kein sessionStorage.</p>",
+ "<p>Replace browser cookies, local storage and IndexedDB from a Playwright-compatible JSON file.</p>": "<p>Ersetzt Browser-Cookies, Local Storage und IndexedDB durch Daten aus einer mit Playwright kompatiblen JSON-Datei.</p>",
+ "<p>Leaves sessionStorage and open tabs unchanged. Fetch or reload pages to use the restored login.</p>": "<p>Lässt sessionStorage und offene Tabs unverändert. Rufen Sie Seiten ab oder laden Sie sie neu, um die wiederhergestellte Anmeldung zu nutzen.</p>",
+ "<p>Open a reusable HTTP session for <code>session_make_request</code>, keeping cookies, connections, and request settings.</p>": "<p>Öffnet eine wiederverwendbare HTTP-Sitzung für <code>session_make_request</code>, die Cookies, Verbindungen und Anfrageeinstellungen behält.</p>",
+ "<p>Close a session and free its resources.</p>": "<p>Schließt eine Sitzung und gibt ihre Ressourcen frei.</p>",
+ "<p>List registered sessions, their status, and effective settings.</p>": "<p>Listet registrierte Sitzungen, ihren Status und die tatsächlich verwendeten Einstellungen auf.</p>",
+ "<p>List completed requests across page changes, with IDs and pagination. Recording starts when the browser session opens.</p>": "<p>Listet abgeschlossene Anfragen über Seitenwechsel hinweg mit IDs und auf mehrere Ergebnisseiten verteilt auf. Die Aufzeichnung beginnt beim Öffnen der Browser-Sitzung.</p>",
+ "<p>Read a complete saved request part without resending it, with structured data and availability notes.</p>": "<p>Liest einen gespeicherten Anfrageteil vollständig, ohne die Anfrage erneut zu senden. Gibt strukturierte Daten und Hinweise zur Verfügbarkeit zurück.</p>",
+ "<p>Read the current page or one element as snapshot, HTML, Markdown, or text without navigating.\nReturn plain text; snapshot search keeps refs, ancestor paths and three lines of nearby context.</p>": "<p>Liest die aktuelle Seite oder ein Element als strukturierte Ansicht, HTML, Markdown oder Text, ohne die Seite zu wechseln. Gibt Klartext zurück. Die Suche in der Seitenansicht behält Referenzen, Pfade der Vorfahren und drei Zeilen nahen Kontext.</p>",
+ "<p>Run mouse, field, key, dialog, and wait actions in order; return plain text without a snapshot.\nStop on the first error, identifying its action; partial effects remain. No retries.\nElement mouse targets auto-wait and scroll into view; coordinates and wheel do not wait for navigation or scrolling.\nCancelled/timed-out clicks attempt button release. Load waits observe the current document, not future navigation.</p>": "<p>Führt Maus-, Feld-, Tasten-, Dialog- und Warteaktionen der Reihe nach aus. Gibt Klartext ohne Seitenansicht zurück. Stoppt beim ersten Fehler und nennt die betroffene Aktion. Bereits ausgeführte Änderungen bleiben erhalten. Keine erneuten Versuche. Bei Mausaktionen auf Elemente wird automatisch gewartet und ins Blickfeld gescrollt. Koordinaten und Mausrad warten nicht auf Navigation oder Scrollen. Bei abgebrochenen Klicks oder Zeitüberschreitungen wird versucht, die Maustaste loszulassen. Wartebedingungen für das Laden beobachten das aktuelle Dokument, keine spätere Navigation.</p>",
+ "<p>Run JavaScript on the current page, await promises, and return JSON text without a snapshot.\nReturn JSON-compatible values; null/undefined become null. Script effects are not undone on failure.\nCancellation stops waiting, but may not stop the script.</p>": "<p>Führt JavaScript auf der aktuellen Seite aus, wartet auf Promises und gibt JSON-Text ohne Seitenansicht zurück. Geben Sie JSON-kompatible Werte zurück. null/undefined werden zu null. Änderungen durch das Skript werden bei Fehlern nicht rückgängig gemacht. Ein Abbruch beendet das Warten, aber möglicherweise nicht das Skript.</p>",
+ "<p>Capture the current page or one element without navigating; return the image and current URL.\nElement capture waits and scrolls into view. Use browser_actions for other waits before capture.</p>": "<p>Erfasst die aktuelle Seite oder ein Element, ohne die Seite zu wechseln. Gibt das Bild und die aktuelle URL zurück. Bei der Aufnahme eines Elements wird gewartet und ins Blickfeld gescrollt. Verwenden Sie browser_actions für weitere Wartebedingungen vor der Aufnahme.</p>",
+ "<p>Make an HTTP request without JavaScript. Suitable for low-to-mid protection.</p>": "<p>Sendet eine HTTP-Anfrage ohne JavaScript. Geeignet für geringen bis mittleren Schutz.</p>",
+ "<p>Fetch a page with a stealth browser and JavaScript rendering.</p>": "<p>Ruft eine Seite mit einem Stealthy-Browser und JavaScript-Ausführung ab.</p>",
+ "<p>Fetch a URL in an open stealthy browser session. Options apply only to this request.</p>": "<p>Ruft eine URL in einer offenen Stealthy-Browser-Sitzung ab. Optionen gelten nur für diese Anfrage.</p>",
+ "<p>Make an HTTP request using the session's cookies, connections, impersonation, and proxy. Options apply to this request.</p>": "<p>Sendet eine HTTP-Anfrage mit den Cookies, Verbindungen, der Browser-Nachbildung und dem Proxy der Sitzung. Optionen gelten für diese Anfrage.</p>",
+ "<p>Serve the MCP server.</p>": "<p>Startet den MCP-Server.</p>",
+ "<p>Serve over the streamable-http transport instead of stdio.</p>": "<p>Verwendet den Transport streamable-http statt stdio.</p>",
+ "<p>The host to bind to when <code>http</code> is enabled.</p>": "<p>Die Adresse, auf der der Server lauscht, wenn <code>http</code> aktiviert ist.</p>",
+ "<p>The port to bind to when <code>http</code> is enabled.</p>": "<p>Der Port, auf dem der Server lauscht, wenn <code>http</code> aktiviert ist.</p>",
+ "<p>Host names to accept, which turns on DNS-rebinding protection.</p>": "<p>Erlaubte Hostnamen. Aktiviert den Schutz vor DNS-Rebinding.</p>",
+ "<p>Start the streamable-http transport without a token. The transport\nrequires authentication by default, so this is the explicit opt-out.</p>": "<p>Startet den Transport streamable-http ohne Token. Er erfordert standardmäßig eine Authentifizierung. Diese Option schaltet sie ausdrücklich aus.</p>",
+ "<p>The <code>Selectors</code> class is a subclass of the builtin <code>List</code> class, which provides a few additional methods.</p>": "<p>Die Klasse <code>Selectors</code> ist eine Unterklasse der eingebauten Klasse <code>List</code> und bietet einige zusätzliche Methoden.</p>",
+ "<p>Returns the first Selector item of the current list or <code>None</code> if the list is empty</p>": "<p>Gibt das erste Selector-Element der aktuellen Liste zurück, oder <code>None</code>, wenn sie leer ist.</p>",
+ "<p>Returns the last Selector item of the current list or <code>None</code> if the list is empty</p>": "<p>Gibt das letzte Selector-Element der aktuellen Liste zurück, oder <code>None</code>, wenn sie leer ist.</p>",
+ "<p>Returns the length of the current list</p>": "<p>Gibt die Länge der aktuellen Liste zurück.</p>",
+ "<p>Call the <code>.xpath()</code> method for each element in this list and return\ntheir results as another <code>Selectors</code> class.</p>": "<p>Ruft <code>.xpath()</code> für jedes Element dieser Liste auf und gibt die Ergebnisse als weiteres <code>Selectors</code>-Objekt zurück.</p>",
+ "<p>A string that will be used to retrieve element's data in adaptive,\notherwise the selector will be used.</p>": "<p>Eine Zeichenfolge zum Abrufen der Elementdaten für die adaptive Funktion. Ohne Angabe wird der Selektor verwendet.</p>",
+ "<p>Call the <code>.css()</code> method for each element in this list and return\ntheir results flattened as another <code>Selectors</code> class.</p>": "<p>Ruft <code>.css()</code> für jedes Element dieser Liste auf und gibt die zusammengefassten Ergebnisse als weiteres <code>Selectors</code>-Objekt zurück.</p>",
+ "<p>Call the <code>.re()</code> method for each element in this list and return\ntheir results flattened as List of TextHandler.</p>": "<p>Ruft <code>.re()</code> für jedes Element dieser Liste auf und gibt die zusammengefassten Ergebnisse als Liste von TextHandler zurück.</p>",
+ "<p>if disabled, function will set the regex to ignore the letters case while compiling it</p>": "<p>Wenn deaktiviert, wird die Regex ohne Unterscheidung von Groß- und Kleinschreibung kompiliert.</p>",
+ "<p>Loop over all current elements and return the first element that matches the passed function</p>": "<p>Durchläuft alle aktuellen Elemente und gibt das erste zurück, das die übergebene Funktion erfüllt.</p>",
+ "<p>A function that takes each element as an argument and returns True/False</p>": "<p>Eine Funktion, die jedes Element als Argument erhält und True/False zurückgibt.</p>",
+ "<p>The first element that match the function or <code>None</code> otherwise.</p>": "<p>Das erste Element, das die Funktion erfüllt, oder <code>None</code>, wenn keines passt.</p>",
+ "<p>Filter current elements based on the passed function</p>": "<p>Filtert die aktuellen Elemente anhand der übergebenen Funktion.</p>",
+ "<p>The new <code>Selectors</code> object or empty list otherwise.</p>": "<p>Das neue <code>Selectors</code>-Objekt oder eine leere Liste, wenn nichts passt.</p>",
+ "<p>Returns the serialized string of the first element, or <code>default</code> if empty.</p>": "<p>Gibt die serialisierte Zeichenfolge des ersten Elements zurück, oder <code>default</code>, wenn die Liste leer ist.</p>",
+ "<p>Serialize all elements and return as a TextHandlers list.</p>": "<p>Serialisiert alle Elemente und gibt sie als TextHandlers-Liste zurück.</p>",
+ "<p>An abstract base class for creating web spiders.</p>": "<p>Eine abstrakte Basisklasse zum Erstellen von Web-Spidern.</p>",
+ "<p>Check the documentation website for more information.</p>": "<p>Weitere Informationen finden Sie auf der Dokumentationswebsite.</p>",
+ "<p>Initialize the spider.</p>": "<p>Initialisiert den Spider.</p>",
+ "<p>Directory for checkpoint files. If provided, enables pause/resume.</p>": "<p>Ordner für Checkpoint-Dateien. Wenn angegeben, sind Pause und Fortsetzung möglich.</p>",
+ "<p>Seconds between periodic checkpoint saves (default 5 minutes).</p>": "<p>Sekunden zwischen regelmäßigen Checkpoint-Speicherungen. Standard: 5 Minuten.</p>",
+ "<p>Access current crawl stats (works during streaming).</p>": "<p>Greift auf die aktuellen Crawl-Statistiken zu. Funktioniert auch beim Streaming.</p>",
+ "<p>Generate initial requests to start the crawl.</p>": "<p>Erzeugt die ersten Anfragen für den Crawl.</p>",
+ "<p>By default, this generates Request objects for each URL in <code>start_urls</code>\nusing the session manager's default session and <code>parse()</code> as callback.</p>": "<p>Erzeugt standardmäßig Request-Objekte für jede URL in <code>start_urls</code>. Nutzt die Standardsitzung des Sitzungsmanagers und <code>parse()</code> als Callback.</p>",
+ "<p>Override this method for more control over initial requests\n(e.g., to add custom headers, use different callbacks, etc.)</p>": "<p>Überschreiben Sie diese Methode, um die ersten Anfragen genauer zu steuern, etwa mit eigenen Headern oder anderen Callbacks.</p>",
+ "<p>Default callback for processing responses</p>": "<p>Standard-Callback zum Verarbeiten von Antworten.</p>",
+ "<p>Called before crawling starts. Override for setup logic.</p>": "<p>Wird vor dem Start des Crawls aufgerufen. Überschreiben Sie die Methode für eigene Vorbereitungsschritte.</p>",
+ "<p>It's enabled if the spider is resuming from a checkpoint, left for the user to use.</p>": "<p>Aktiviert, wenn der Spider von einem Checkpoint fortgesetzt wird. Sie können diesen Wert in Ihrem Code verwenden.</p>",
+ "<p>Called after crawling finishes. Override for cleanup logic.</p>": "<p>Wird nach dem Ende des Crawls aufgerufen. Überschreiben Sie die Methode, um Ressourcen freizugeben.</p>",
+ "<p>Handle request errors for all spider requests.</p>": "<p>Behandelt Anfragefehler für alle Anfragen des Spiders.</p>",
+ "<p>Override for custom error handling.</p>": "<p>Überschreiben Sie die Methode für eine eigene Fehlerbehandlung.</p>",
+ "<p>A hook to be overridden by users to do some processing on scraped items, return <code>None</code> to drop the item silently.</p>": "<p>Ein Hook, den Sie überschreiben können, um extrahierte Datensätze zu verarbeiten. Geben Sie <code>None</code> zurück, um den Datensatz ohne Meldung zu verwerfen.</p>",
+ "<p>Check if the response is blocked. Users should override this for custom detection logic.</p>": "<p>Prüft, ob die Antwort blockiert ist. Überschreiben Sie die Methode für eine eigene Erkennung.</p>",
+ "<p>Users should override this to prepare the blocked request before retrying, if needed.</p>": "<p>Überschreiben Sie die Methode bei Bedarf, um eine blockierte Anfrage vor dem nächsten Versuch anzupassen.</p>",
+ "<p>String representation of the spider.</p>": "<p>Darstellung des Spiders als Zeichenfolge.</p>",
+ "<p>Configure sessions for this spider.</p>": "<p>Konfiguriert die Sitzungen dieses Spiders.</p>",
+ "<p>Override this method to add custom sessions.\nThe default implementation creates a FetcherSession session.</p>": "<p>Überschreiben Sie diese Methode, um eigene Sitzungen hinzuzufügen. Die Standardimplementierung erstellt eine FetcherSession-Sitzung.</p>",
+ "<p>The first session added becomes the default for <code>start_requests()</code> unless specified otherwise.</p>": "<p>Die zuerst hinzugefügte Sitzung wird zur Standardsitzung für <code>start_requests()</code>, wenn nichts anderes angegeben ist.</p>",
+ "<p>SessionManager to configure</p>": "<p>Der zu konfigurierende SessionManager.</p>",
+ "<p>Request graceful shutdown of the crawling process.</p>": "<p>Fordert einen geordneten Stopp des Crawls an.</p>",
+ "<p>Run the spider and return results.</p>": "<p>Führt den Spider aus und gibt die Ergebnisse zurück.</p>",
+ "<p>This is the main entry point for running a spider.\nHandles async execution internally via anyio.</p>": "<p>Der Haupteinstiegspunkt zum Ausführen eines Spiders. Verwaltet die asynchrone Ausführung intern mit anyio.</p>",
+ "<p>Pressing Ctrl+C will initiate graceful shutdown (waits for active tasks to complete).\nPressing Ctrl+C a second time will force immediate stop.</p>": "<p>Ctrl+C leitet einen geordneten Stopp ein und wartet auf aktive Aufgaben. Ein zweites Ctrl+C erzwingt den sofortigen Stopp.</p>",
+ "<p>If crawldir is set, a checkpoint will also be saved on graceful shutdown,\nallowing you to resume the crawl later by running the spider again.</p>": "<p>Wenn crawldir gesetzt ist, wird beim geordneten Stopp auch ein Checkpoint gespeichert. Beim nächsten Start des Spiders können Sie den Crawl damit fortsetzen.</p>",
+ "<p>Whether to use the faster uvloop/winloop event loop implementation, if available.</p>": "<p>Gibt an, ob die schnellere Ereignisschleife von uvloop/winloop verwendet werden soll, falls verfügbar.</p>",
+ "<p>Asyncio backend options to be used with <code>anyio.run</code></p>": "<p>Optionen des Asyncio-Backends für <code>anyio.run</code>.</p>",
+ "<p>Stream items as they're scraped. Ideal for long-running spiders or building applications on top of the spiders.</p>": "<p>Gibt Datensätze direkt beim Extrahieren als Stream aus. Geeignet für lange Crawls oder Anwendungen, die auf Spidern aufbauen.</p>",
+ "<p>Must be called from an async context. Yields items one by one as they are scraped.\nAccess <code>spider.stats</code> during iteration for real-time statistics.</p>": "<p>Muss aus einem asynchronen Kontext aufgerufen werden. Gibt Datensätze einzeln direkt nach dem Extrahieren aus. Greifen Sie während der Iteration auf <code>spider.stats</code> zu, um aktuelle Statistiken zu erhalten.</p>",
+ "<p>Note: SIGINT handling for pause/resume is not available in stream mode.</p>": "<p>Hinweis: Die Behandlung von SIGINT für Pause und Fortsetzung ist im Streaming-Modus nicht verfügbar.</p>",
+ "<p>Create a copy of this request.</p>": "<p>Erstellt eine Kopie dieser Anfrage.</p>",
+ "<p>Generate a unique fingerprint for deduplication.</p>": "<p>Erzeugt einen eindeutigen Fingerprint zum Erkennen von Duplikaten.</p>",
+ "<p>Caches the result in self._fp after first computation.</p>": "<p>Speichert das Ergebnis nach der ersten Berechnung in self._fp zwischen.</p>",
+ "<p>Compare requests by priority</p>": "<p>Vergleicht Anfragen nach ihrer Priorität.</p>",
+ "<p>Requests are equal if they have the same fingerprint.</p>": "<p>Anfragen sind gleich, wenn sie denselben Fingerprint haben.</p>",
+ "<p>Prepare state for pickling - store callback as name string for pickle compatibility.</p>": "<p>Bereitet den Zustand für pickle vor. Speichert den Namen des Callbacks als String, damit er mit pickle kompatibel ist.</p>",
+ "<p>Restore state from pickle - callback restored later via _restore_callback().</p>": "<p>Stellt den Zustand aus pickle wieder her. Der Callback wird später mit _restore_callback() wiederhergestellt.</p>",
+ "<p>Complete result from a spider run.</p>": "<p>Das vollständige Ergebnis eines Spider-Durchlaufs.</p>",
+ "<p>True if the crawl completed normally (not paused).</p>": "<p>True, wenn der Crawl normal abgeschlossen wurde und nicht pausiert ist.</p>",
+ "<p>Statistics for a crawl run.</p>": "<p>Statistiken eines Crawl-Durchlaufs.</p>",
+ "<p>A list of scraped items with export capabilities.</p>": "<p>Eine Liste extrahierter Datensätze mit Exportfunktionen.</p>",
+ "<p>Export items to a JSON file.</p>": "<p>Exportiert Datensätze in eine JSON-Datei.</p>",
+ "<p>Path to the output file</p>": "<p>Pfad zur Ausgabedatei.</p>",
+ "<p>Pretty-print with 2-space indentation (slightly slower)</p>": "<p>Formatiert die Ausgabe mit 2 Leerzeichen Einrückung. Etwas langsamer.</p>",
+ "<p>Export items as JSON Lines (one JSON object per line).</p>": "<p>Exportiert Datensätze als JSON Lines, mit einem JSON-Objekt pro Zeile.</p>",
+ "<p>Export items to a CSV file.</p>": "<p>Exportiert Datensätze in eine CSV-Datei.</p>",
+ "<p>Items that don't share the same keys are still written, with the missing cells left empty, and any value\nthat isn't a scalar (a nested dictionary or a list) is written as JSON.</p>": "<p>Auch Datensätze mit unterschiedlichen Schlüsseln werden geschrieben. Fehlende Zellen bleiben leer. Nicht skalare Werte, etwa verschachtelte Wörterbücher oder Listen, werden als JSON geschrieben.</p>",
+ "<p>The columns to write, defaulting to every key found in the items, in the order they appeared</p>": "<p>Die zu schreibenden Spalten. Standardmäßig alle Schlüssel der Datensätze in der Reihenfolge ihres ersten Auftretens.</p>",
+ "<p>The character separating the columns</p>": "<p>Das Zeichen zwischen den Spalten.</p>",
+ "<p>Export items to an XML file.</p>": "<p>Exportiert Datensätze in eine XML-Datei.</p>",
+ "<p>Each item becomes an element whose children are named after the item's keys. Keys that aren't valid XML\nnames are rewritten and keep the original in a <code>name</code> attribute, and any value that isn't a scalar\n(a nested dictionary or a list) is written as JSON.</p>": "<p>Jeder Datensatz wird zu einem Element, dessen Kinder nach seinen Schlüsseln benannt sind. Schlüssel, die keine gültigen XML-Namen sind, werden umgeschrieben. Das Original bleibt in einem <code>name</code>-Attribut erhalten. Nicht skalare Werte, etwa verschachtelte Wörterbücher oder Listen, werden als JSON geschrieben.</p>",
+ "<p>The name of the element wrapping all the items</p>": "<p>Name des Elements, das alle Datensätze umschließt.</p>",
+ "<p>The name of the element wrapping every item</p>": "<p>Name des Elements, das jeden einzelnen Datensatz umschließt.</p>",
+ "<p>Pretty-print the file instead of writing it on a single line</p>": "<p>Formatiert die Datei lesbar, statt alles in eine Zeile zu schreiben.</p>",
+ "<p>Manages pre-configured session instances.</p>": "<p>Verwaltet vorkonfigurierte Sitzungsinstanzen.</p>",
+ "<p>Register a session instance.</p>": "<p>Registriert eine Sitzungsinstanz.</p>",
+ "<p>Name to reference this session in requests</p>": "<p>Name, mit dem diese Sitzung in Anfragen ausgewählt wird.</p>",
+ "<p>Your pre-configured session instance</p>": "<p>Ihre vorkonfigurierte Sitzungsinstanz.</p>",
+ "<p>If True, this becomes the default session</p>": "<p>Bei True wird dies die Standardsitzung.</p>",
+ "<p>If True, the session will be started only when a request uses its ID.</p>": "<p>Bei True startet die Sitzung erst, wenn eine Anfrage ihre ID verwendet.</p>",
+ "<p>Removes a session.</p>": "<p>Entfernt eine Sitzung.</p>",
+ "<p>ID of session to remove</p>": "<p>ID der zu entfernenden Sitzung.</p>",
+ "<p>Remove and returns a session.</p>": "<p>Entfernt eine Sitzung und gibt sie zurück.</p>",
+ "<p>Start all sessions that aren't already alive.</p>": "<p>Startet alle Sitzungen, die noch nicht aktiv sind.</p>",
+ "<p>Close all registered sessions.</p>": "<p>Schließt alle registrierten Sitzungen.</p>",
+ "<p>Check if a session ID is registered.</p>": "<p>Prüft, ob eine Sitzungs-ID registriert ist.</p>",
+ "<p>Number of registered sessions.</p>": "<p>Anzahl der registrierten Sitzungen.</p>"
+} %}
+{% macro translate(value) %}
+ {% set result = namespace(html=value | replace("Bases:", "Basisklassen:")) %}
+ {% for source, target in translations.items() %}
+ {% set result.html = result.html | replace(source, target | safe) %}
+ {% endfor %}
+ {{ result.html | safe }}
+{% endmacro %}
diff --git a/zensical-base.yml b/zensical-base.yml
index 9a201e6..699bdb0 100644
--- a/zensical-base.yml
+++ b/zensical-base.yml
@@ -129,6 +129,9 @@ extra:
- name: Français
link: https://scrapling.readthedocs.io/en/latest/fr/
lang: fr
+ - name: Deutsch
+ link: https://scrapling.readthedocs.io/en/latest/de/
+ lang: de
watch:
- zensical-base.yml
- docs/assets
diff --git a/zensical.de.yml b/zensical.de.yml
new file mode 100644
index 0000000..2ab9552
--- /dev/null
+++ b/zensical.de.yml
@@ -0,0 +1,99 @@
+INHERIT: zensical-base.yml
+site_description: Scrapling - Daten aus dem modernen Web einfach extrahieren.
+site_url: https://scrapling.readthedocs.io/en/latest/de/
+docs_dir: docs/locales/de
+site_dir: site/de
+edit_uri: edit/main/docs/locales/de/
+copyright: Copyright &copy; 2025 Karim Shoair - <a href="#__consent">Cookie-Einstellungen ändern</a>
+nav:
+- Einführung: index.md
+- Überblick: overview.md
+- Leistungstests: benchmarks.md
+- Anleitung:
+ - Seiten auswerten:
+ - Elemente auswählen: parsing/selection.md
+ - Hauptklassen: parsing/main_classes.md
+ - Adaptives Scraping: parsing/adaptive.md
+ - Seiten abrufen:
+ - Einen Fetcher wählen: fetching/choosing.md
+ - HTTP-Anfragen: fetching/static.md
+ - Abrufen mit dem Browser: fetching/stealthy.md
+ - Spider:
+ - Architektur: spiders/architecture.md
+ - Erste Schritte: spiders/getting-started.md
+ - Anfragen und Antworten: spiders/requests-responses.md
+ - Sitzungen: spiders/sessions.md
+ - Proxys und Sperren: spiders/proxy-blocking.md
+ - Allgemeine Vorlagen: spiders/generic-templates.md
+ - Plattformvorlagen: spiders/platform-templates.md
+ - Erweiterte Funktionen: spiders/advanced.md
+ - Kommandozeile:
+ - Überblick: cli/overview.md
+ - Interaktive Shell: cli/interactive-shell.md
+ - Extraktionsbefehle: cli/extract-commands.md
+ - Nutzung mit KI:
+ - MCP-Server: ai/mcp-server.md
+ - Agent Skill: ai/agent-skill.md
+ - RAG-Systeme aufbauen: ai/building-rag-systems.md
+ - Integration und Umstieg:
+ - Integration mit Scrapy: integrations/scrapy.md
+ - Von BeautifulSoup umsteigen: tutorials/migrating_from_beautifulsoup.md
+- Tutorials:
+ - Eine kostenlose Alternative zur Datenextraktion mit KI: tutorials/replacing_ai.md
+- Entwicklung:
+ - API-Referenz:
+ - Selector: api-reference/selector.md
+ - Fetcher: api-reference/fetchers.md
+ - MCP-Server: api-reference/mcp-server.md
+ - Eigene Datentypen: api-reference/custom-types.md
+ - Response: api-reference/response.md
+ - Spider: api-reference/spiders.md
+ - Proxy-Rotation: api-reference/proxy-rotation.md
+ - Ein eigenes System zum Wiederfinden erstellen: development/adaptive_storage_system.md
+ - Die Datentypen von Scrapling nutzen: development/scrapling_custom_types.md
+- Unterstützung und Werbung: donate.md
+- Mitwirken: https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md
+- Änderungsverlauf: https://github.com/D4Vinci/Scrapling/blob/main/CHANGELOG.md
+theme:
+ language: de
+ palette:
+ - media: '(prefers-color-scheme: light)'
+ scheme: default
+ accent: green
+ primary: deep purple
+ toggle:
+ icon: lucide/sun
+ name: Zum dunklen Modus wechseln
+ - media: '(prefers-color-scheme: dark)'
+ scheme: slate
+ accent: light green
+ primary: deep purple
+ toggle:
+ icon: lucide/moon
+ name: Zum hellen Modus wechseln
+markdown_extensions:
+ toc:
+ permalink_title: Dauerhafter Link
+plugins:
+ mkdocstrings:
+ locale: de
+extra:
+ analytics:
+ feedback:
+ title: War diese Seite hilfreich?
+ ratings:
+ - icon: material/heart
+ name: Diese Seite war hilfreich
+ data: 1
+ note: Vielen Dank für Ihre Rückmeldung!
+ - icon: material/heart-broken
+ name: Diese Seite kann verbessert werden
+ data: 0
+ note: 'Vielen Dank für Ihre Rückmeldung! Helfen Sie uns, diese Seite zu verbessern, und <a href="https://github.com/D4Vinci/Scrapling/issues/new?template=04-docs_issue.yml" target="_blank" rel="noopener">melden Sie ein Problem mit der Dokumentation</a>.'
+ consent:
+ title: Zustimmung zu Cookies
+ description: Wir verwenden Cookies, um Ihre Einstellungen zu speichern und zu erfahren, ob die Dokumentation Ihnen weiterhilft. Ihre Zustimmung hilft uns, sie zu verbessern.
+ actions:
+ - accept
+ - reject
+ - manage