Zoro-Produktdaten scrapenIndustriebedarf, Preise und Lagerbestand

Zoro.com ist ein großer Industrieversandhändler mit Millionen von Produkten: Werkzeug, Ausrüstung, Befestigungsmittel, Sicherheitsausrüstung und MRO-Teile. Jedes Listing enthält Marke, Preis, Zoro-Nummer und Lagerstatus. Diese Daten sind ein klares, öffentlich zugängliches Signal für alle, die im Industriebereich Preise verfolgen, Kataloge recherchieren oder Wettbewerbsanalysen durchführen. Deshalb behalten Händler, Einkaufsteams und Analysten sie im Blick.

Dieser Leitfaden zeigt Ihnen, wie Sie Zoro-Produktdaten scrapen mit Python. Sie bauen einen kleinen, lauffähigen Scraper, der Zoro-Such- und Produktseiten über die Crawling API abruft, für jedes Element einen strukturierten Datensatz parst, die Paginierung verarbeitet und die Ergebnisse als JSON und CSV exportiert. Die gesamte Anleitung beschränkt sich auf öffentliche Katalogdaten: Marken, Titel, Preise, Zoro-Nummern und Verfügbarkeiten, die jeder auf einer Such- oder Produktseite ohne Anmeldung sehen kann.

Was Sie bauen werden

Ein Python-Skript, das eine Zoro-Such-URL entgegennimmt, die gerenderte Seite über die Crawling API abruft und pro Produkt einen strukturierten Datensatz extrahiert. Als laufendes Beispiel verwenden wir die Suche nach einem Werkzeugkasten, dieselbe Abfrage wie in der ursprünglichen Anleitung, und ziehen folgende Felder aus jedem Listing:

• Marke der Herstellername auf der Produktkarte.
• Titel der Produktname in der Auflistung.
• Preis der angegebene Preis, sofern das Produkt einen hat.
• Zoro-Nummer die SKU-ähnliche Kennung aus der Produkt-URL, zum Beispiel G6893443.
• Verfügbarkeit der Lagerstatus, etwa auf Lager oder im Rückstand.
• Link die absolute URL zur eigenen Detailseite des Produkts.

Warum eine einfache Anfrage bei Zoro scheitert

Wenn Sie einen einfachen HTTP-Client auf eine Zoro-Such-URL richten, erhalten Sie selten das Produktraster, das Sie suchen. Zwei Dinge arbeiten gegen Sie. Erstens rendert Zoro einen Großteil des Listings clientseitig: Die Seite liefert eine leichte Shell und füllt die Produktkarten erst, wenn JavaScript ausgeführt wird. Das initiale HTML fehlt daher häufig die gewünschten Elemente. Zweitens erkennt Zoro automatisierten Traffic. Datacenter-IP-Bereiche und Anfragemuster, die nicht wie ein echter Browser aussehen, werden mit einer Challenge-Seite oder einer kompletten Sperrung beantwortet, bevor Sie überhaupt die Listings erreichen.

Ein funktionierender Zoro-Scraper benötigt also zwei Dinge in einer einzigen Anfrage: einen Browser, der die Seite rendert, und eine IP, die Zoro als echten Käufer erkennt. Das können Sie selbst mit einem Headless-Browser und einem Pool aus rotierenden Residential-Proxys aufbauen, aber diesen Stack in Betrieb zu halten ist der Großteil der Arbeit. Die Crawling API vereint beides in einem einzigen Aufruf: Sie senden die URL, sie rendert die Seite hinter einer vertrauenswürdigen Residential-IP, übernimmt die Rotation und das CAPTCHA-Solving und gibt fertiges HTML zurück, das Sie parsen können.

Voraussetzungen

Bevor Sie Code schreiben, müssen Sie einige Dinge einrichten. Das dauert nicht lange.

Python-Grundkenntnisse. Sie sollten in der Lage sein, ein Python-Skript zu schreiben, auszuführen und Pakete mit pip zu installieren. Wenn Sie neu in der Sprache sind, erklärt der Leitfaden zum Web-Scraping mit Python das Niveau, das dieses Tutorial voraussetzt.

Python 3.8 oder höher. Prüfen Sie Ihre Version mit python --version (oder python3 --version). Wenn Sie es nicht haben, installieren Sie es von python.org und stellen Sie sicher, dass Python in Ihrem System-PATH enthalten ist.

Ein Crawlbase-Konto und Token. Melden Sie sich für ein kostenloses Konto an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token von der Kontodokumentationsseite. Der kostenlose Tarif umfasst bis zu 5.000 Anfragen ohne Kreditkarte, was für Aufbau und Tests dieses Scrapers mehr als ausreicht. Da Zoro JavaScript-gerendert ist, verwenden Sie für diese Anfragen Ihr JavaScript-Token. Behandeln Sie das Token wie ein Passwort und verwahren Sie es außerhalb der Versionskontrolle.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die zwei Bibliotheken, die der Scraper benötigt. crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, sodass Sie jedes Feld aus den Produktkarten per CSS-Selektor herausziehen können.

python --version

python -m venv zoro_env
source zoro_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit zoro_env\Scripts\activate statt der source-Zeile. Sobald beide Bibliotheken installiert sind, legen Sie die Skriptdatei an, die im weiteren Verlauf des Leitfadens aufgebaut wird:

touch zoro_scraper.py

Die Zoro-Suchseite verstehen

Eine Zoro-Suche befindet sich unter einer stabilen URL, die aus dem q-Abfrageparameter aufgebaut wird, zum Beispiel https://www.zoro.com/search?q=tool+box, und paginiert mit einem page-Parameter als &page=2. Die Seite legt ein Raster aus Produktkarten an, eine pro Artikel, mit denselben wenigen Feldern: Markenname, Titel, Preis, Vorschaubild und Link zur Detailseite des Produkts.

Bevor Sie Selektoren schreiben, öffnen Sie eine Zoro-Suchseite in Ihrem Browser, klicken Sie mit der rechten Maustaste auf eine Produktkarte und wählen Sie Untersuchen. Im DOM-Explorer können Sie die CSS-Selektoren für jedes Feld ablesen:

• Markenname innerhalb eines <span> mit der Klasse brand-name.
• Produkttitel innerhalb eines <div> mit der Klasse product-title.
• Preis innerhalb eines <div> mit der Klasse price.
• Produkt-URL im href eines <a> innerhalb von div.product-title.
• Produktbild im src eines <img> mit data-za="product-image".

Die Produktkarten selbst befinden sich in einem section[data-za="product-cards-list"]-Container, jede als div.search-product-card, was das Schleifenziel ist. Die Zoro-Nummer ist kein eigenständiges Element auf der Karte: Sie ist das SKU-Segment in der Produkt-URL (das G6893443 in /i/G6893443/), daher leiten Sie sie vom Link ab, anstatt sie direkt zu selektieren.

Schritt 1: Die gerenderte Suchseite abrufen

Beginnen Sie damit, die fertige Seite zu holen. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem Token, setzen Sie die Such-URL und fordern Sie sie an. Das Prüfen des Statuscodes vor dem Parsen hält Fehler sichtbar statt still.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    search_url = "https://www.zoro.com/search?q=tool+box"
    html = crawl(search_url)
    print(html[:500] if html else "No HTML returned")

Die zwei Wait-Optionen sind für ein Raster wichtig, das sich beim Laden der Seite füllt. ajax_wait weist die API an, auf den Abschluss asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl Millisekunden an (hier 5000, da Zoros Listingseiten langsam sein können), damit die spät rendernden Karten erscheinen, bevor die Seite aufgezeichnet wird. Führen Sie das Skript aus, und Sie sollten echtes Listing-Markup sehen, keine Challenge-Shell. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Produktkarten mit BeautifulSoup parsen

Mit gerendertem HTML laden Sie es in BeautifulSoup, finden jede Produktkarte und ziehen jedes Feld per Selektor heraus. Jede Karte befindet sich im section[data-za="product-cards-list"]-Container als div.search-product-card. Lesen Sie Marke, Titel, Preis, Bild und Link von der Karte ab, leiten Sie dann die Zoro-Nummer aus dem Link ab. Kapseln Sie jede Karte in einem try/except, damit ein fehlerhaftes Listing den gesamten Lauf nicht abstürzen lässt.

import re
from bs4 import BeautifulSoup

BASE = "https://www.zoro.com"

def text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else None

def zoro_number(url):
    match = re.search(r"/i/(G\d+)/", url)
    return match.group(1) if match else None

def scrape_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select('section[data-za="product-cards-list"] > div.search-product-card')
    results = []
    for card in cards:
        try:
            anchor = card.select_one("div.product-title a")
            href = anchor["href"] if anchor else ""
            link = BASE + href if href.startswith("/") else href
            img = card.select_one('img[data-za="product-image"]')
            results.append({
                "brand": text_of(card, "span.brand-name"),
                "title": text_of(card, "div.product-title"),
                "price": text_of(card, "div.price"),
                "zoro_number": zoro_number(link),
                "availability": text_of(card, "div.availability"),
                "image_url": img["src"] if img else None,
                "link": link,
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

Der Helfer text_of fragt ein Element innerhalb einer Karte ab und gibt None zurück, wenn es fehlt, anstatt bei einem .get_text()-Aufruf auf nichts zu werfen. Das macht die Extraktion robust, wenn ein Feld fehlt, was häufig vorkommt, da nicht jede Karte einen Preis oder ein Verfügbarkeits-Badge zeigt. Der Helfer zoro_number zieht die G-prefixierte SKU aus der Produkt-URL mit einem kleinen regulären Ausdruck, und der Link wird in eine absolute URL normalisiert, da Zoro einen relativen href liefert.

Schritt 3: Paginierung verarbeiten und JSON und CSV exportieren

Eine Suchseite ist eine Demo; ein echter Job durchläuft das gesamte Ergebnisset. Zoro paginiert mit dem page-Parameter, also hängen Sie &page=N an und schleifen, bis eine Seite keine Karten mehr zurückgibt. Verbinden Sie nun Abruf, Parsing und Paginierungsschleife in einem lauffähigen Skript und schreiben Sie die Datensätze sowohl als JSON als auch als CSV, damit Sie sie in ein Notebook oder eine Tabelle laden können.

import csv
import json
import re
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
BASE = "https://www.zoro.com"
FIELDS = ["brand", "title", "price", "zoro_number", "availability", "image_url", "link"]

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else None

def zoro_number(url):
    match = re.search(r"/i/(G\d+)/", url)
    return match.group(1) if match else None

def scrape_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select('section[data-za="product-cards-list"] > div.search-product-card')
    results = []
    for card in cards:
        try:
            anchor = card.select_one("div.product-title a")
            href = anchor["href"] if anchor else ""
            link = BASE + href if href.startswith("/") else href
            img = card.select_one('img[data-za="product-image"]')
            results.append({
                "brand": text_of(card, "span.brand-name"),
                "title": text_of(card, "div.product-title"),
                "price": text_of(card, "div.price"),
                "zoro_number": zoro_number(link),
                "availability": text_of(card, "div.availability"),
                "image_url": img["src"] if img else None,
                "link": link,
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

def scrape_all_pages(search_url, max_pages=5):
    all_rows = []
    for page in range(1, max_pages + 1):
        page_url = f"{search_url}&page={page}"
        print(f"Scraping page {page}...")
        html = crawl(page_url)
        if not html:
            break
        rows = scrape_listings(html)
        if not rows:
            print("No more products. Stopping.")
            break
        all_rows.extend(rows)
        time.sleep(2)
    return all_rows

def export(rows, name="zoro_listings"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2, ensure_ascii=False)
    with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} products to {name}.json and {name}.csv")

def main():
    search_url = "https://www.zoro.com/search?q=tool+box"
    rows = scrape_all_pages(search_url, max_pages=3)
    export(rows)

if __name__ == "__main__":
    main()

Führen Sie das vollständige Skript mit python zoro_scraper.py aus. Es durchläuft bis zu max_pages Suchseiten, parst eine Zeile pro Produkt und schreibt sowohl zoro_listings.json als auch zoro_listings.csv. Die Schleife scrape_all_pages stoppt frühzeitig, wenn eine Seite keine Karten zurückgibt, und time.sleep(2) zwischen den Anfragen taktet den Lauf. Die gemeinsame Liste FIELDS hält die CSV-Spaltenreihenfolge synchron mit den Dictionary-Schlüsseln, sodass die beiden Exporte nie auseinanderdriften.

Wie die Ausgabe aussieht

Sie erhalten eine saubere Liste von Produktdatensätzen in Seitenreihenfolge, bereit zum Schreiben in JSON, CSV oder eine Datenbank.

[
  {
    "brand": "Apex Tool Group",
    "title": "3 Drawer Tool Box",
    "price": "$149.99 /ea",
    "zoro_number": "G6893443",
    "availability": "In Stock",
    "image_url": "https://www.zoro.com/static/cms/product/prev/KDT83151xx1200.jpg",
    "link": "https://www.zoro.com/apex-tool-group-3-drawer-tool-box-83151/i/G6893443/"
  },
  {
    "brand": "Dewalt",
    "title": "Rolling Tool Box, Plastic, Black, 28 in W",
    "price": "$43.19 /ea",
    "zoro_number": "G3778857",
    "availability": "In Stock",
    "image_url": "https://www.zoro.com/static/cms/product/prev/Z1wK0zqcpEx-.JPG",
    "link": "https://www.zoro.com/dewalt-rolling-tool-box-plastic-black-28-in-w-dwst28100/i/G3778857/"
  }
]

Einzelne Produktseiten scrapen

Der Such-Scraper liefert Ihnen das Listing-Raster. Wenn Sie tiefere Details benötigen (eine vollständige Beschreibung, die Spezifikationstabelle, jedes Bild), folgen Sie dem link aus jedem Datensatz zu seiner Produktseite und parsen Sie diese. Zoro stellt auf einer Produktseite folgende Elemente bereit:

• Produkttitel in einem <h1> mit data-za="product-name".
• Preis in einem <div> mit data-za="product-price".
• Beschreibung in div.product-description div.description-text.
• Spezifikationen Zeilen in einer <table> innerhalb von div.product-details-info, zwei <td>-Zellen pro Zeile.
• Produktbilder die <img>-Tags mit der Klasse product-image innerhalb von div.product-images.

import re
from bs4 import BeautifulSoup

def clean(value):
    return re.sub(r"\s+", " ", value).strip() if value else None

def scrape_product_page(product_url):
    html = crawl(product_url)
    if not html:
        return {}
    soup = BeautifulSoup(html, "html.parser")

    title = soup.select_one('h1[data-za="product-name"]')
    price = soup.select_one('div[data-za="product-price"]')
    desc = soup.select_one("div.product-description div.description-text")

    specs = {}
    for row in soup.select("div.product-details-info table tr"):
        cells = row.find_all("td")
        if len(cells) == 2:
            specs[clean(cells[0].text)] = clean(cells[1].text)

    images = [img["src"] for img in soup.select("div.product-images img.product-image") if img.get("src")]

    return {
        "title": clean(title.text) if title else None,
        "price": clean(price.text) if price else None,
        "zoro_number": zoro_number(product_url),
        "description": clean(desc.text) if desc else None,
        "specifications": specs,
        "image_urls": images,
        "url": product_url,
    }

Dies verwendet dieselben Helfer crawl und zoro_number aus dem Listing-Scraper, sodass Sie ihm jeden link aus den Suchergebnissen übergeben können. Der Helfer clean kollabiert Leerzeichen zu einzelnen Leerzeichen, was für Zoros Spezifikationstabellen und mehrzeilige Beschreibungen wichtig ist. Die Spezifikationen kommen als flaches Schlüssel-Wert-Dictionary zurück, ein Eintrag pro zweizellige Tabellenzeile, was direkt in einen DataFrame oder einen Datenbankspalten-Satz geladen werden kann.

Nicht geblockt bleiben

Auch wenn das Rendering gehandhabt wird, achtet Zoro auf scraper-ähnlichen Traffic. Einige Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes schwierige kommerzielle Ziel.

• Pacing der Anfragen. Verteilen Sie Anfragen mit einer Verzögerung zwischen Seiten, anstatt alles mit voller Geschwindigkeit zu crawlen. Planen Sie schwerere Jobs in Schwachlastzeiten, um Zoros Server zu entlasten.
• Auf Rotation setzen. Ein Pool aus Residential-IPs verteilt Anfragen auf viele echte Nutzeradressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Nur speichern, was Sie brauchen. Speichern Sie die Katalogfelder, die Ihr Projekt verwendet, und verwerfen Sie den Rest. Überprüfen Sie Ihre Selektoren regelmäßig, damit der Scraper mit Markup-Änderungen Schritt hält.

Das umfassendere Playbook zum Vermeiden von Sperren finden Sie unter wie man Websites scrapt, ohne gesperrt zu werden. Wenn Preisverfolgung Ihr Ziel ist, zeigt der Leitfaden über Web-Scraping für Preisanalyse, wie Sie diese Momentaufnahmen in einen Trendfeed umwandeln, und der Überblick über E-Commerce-Web-Scraping deckt das breitere Muster über Einzelhandelsseiten ab. Für ein ähnliches MRO- und Bürobedarf-Ziel lesen Sie wie man Office Depot scrapt.

Ist es legal, Zoro zu scrapen?

Ob das Scrapen von Zoro erlaubt ist, hängt von Zoros Nutzungsbedingungen, Ihrer Gerichtsbarkeit und der Verwendung der Daten ab. Zoros Bedingungen schränken den automatisierten Zugriff ein, sodass Scraping unabhängig von der Sorgfalt Ihrer Werkzeuge gegen diese Bedingungen verstoßen kann. Keiner der hier aufgeführten Code ändert daran etwas; er macht nur den technischen Teil lauffähig. Lesen Sie Zoros Nutzungsbedingungen und seine robots.txt und behandeln Sie beides als Grenze für das, was Sie sammeln. Bei kommerziellem oder wettbewerbsbezogenem Einsatz wird das rechtliche Bild komplexer, und es ist sinnvoll, einen Rechtsexperten zu Ihrem spezifischen Fall zu konsultieren.

Einige Grundsätze, an denen man festhalten sollte. Sammeln Sie nur öffentliche Daten: die Marken, Titel, Preise, Zoro-Nummern, Verfügbarkeiten und Listing-Links, die jeder auf einer Such- oder Produktseite ohne Konto sehen kann. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie Zoros Server nicht belasten, und vermeiden Sie personenbezogene Daten, einschließlich allem, was mit identifizierbaren Käufern, Rezensenten oder Verkäufern verbunden ist, über das hinaus, was öffentlich aufgeführt ist. Verbreiten Sie Zoros urheberrechtlich geschützte Produktfotografien oder Beschreibungen nicht in großem Umfang. Wenn Sie die Daten kommerziell wiederverwenden möchten, holen Sie sich eine Genehmigung oder ein offizielles Abkommen, anstatt davon auszugehen, dass Schweigen Zustimmung bedeutet.

Dieser Leitfaden beschränkt sich bewusst auf öffentliche Katalogseiten, weil das die Grenze ist, die die Arbeit vertretbar macht. Er behandelt nichts hinter einem Login, Konto- oder Bestelldaten, persönliche Informationen oder Versuche, Authentifizierung oder ein CAPTCHA zu umgehen, zu dem Sie keinen Zugang haben. Wenn Zoro einen Geschäftsdaten-Feed, ein Partnerprogramm oder eine offizielle API für Ihren Anwendungsfall anbietet, ist das das richtige Werkzeug, wenn Sie große Mengen, garantierte Struktur oder kommerzielle Rechte benötigen. Wenn Ihr Projekt mehr als öffentliche Katalogdaten benötigt, ist ein offizieller Kanal oder ein Datenabkommen der richtige Weg, kein clevererer Scraper.

Häufig gestellte Fragen

Warum liefert eine einfache Anfrage keine Produkte von Zoro?

Zwei Gründe. Zoro füllt einen Großteil seines Produktrasters clientseitig beim Laden der Seite, sodass eine rohe Anfrage oft eine Shell ohne die Listings zurückgibt. Außerdem fordert oder blockiert Zoro Traffic, der nicht wie ein echter Browser aussieht. Das Rendern der Seite über die Crawling API hinter einer vertrauenswürdigen IP löst beides, weshalb der Scraper seine Anfrage mit ajax_wait und einem page_wait von 5000 Millisekunden darüber leitet.

Welche Felder kann ich von einer Zoro-Suchseite extrahieren?

Von jeder Produktkarte können Sie Marke (span.brand-name), Titel (div.product-title), Preis (div.price), Vorschaubild (img[data-za="product-image"]) und den Produktlink lesen. Die Zoro-Nummer ist die G-prefixierte SKU in diesem Link, die Sie mit einem kurzen regulären Ausdruck herausziehen. Produktseiten fügen eine vollständige Beschreibung, eine Spezifikationstabelle und den größeren Bildsatz hinzu.

Wie gehe ich mit der Paginierung bei Zoro um?

Zoro paginiert mit dem page-Abfrageparameter. Hängen Sie &page=2, &page=3 und so weiter an die Such-URL und schleifen, bis eine Seite keine Produktkarten oder eine von Ihnen gesetzte Seitenobergrenze zurückgibt. Fügen Sie eine kurze Verzögerung zwischen Anfragen hinzu, damit Sie nicht mit voller Geschwindigkeit crawlen.

Wie erhalte ich die Zoro-Nummer für ein Produkt?

Die Zoro-Nummer ist das SKU-Segment in der Produkt-URL, das G6893443 in /i/G6893443/. Der Scraper leitet sie mit einem regulären Ausdruck gegen den Link ab, anstatt ein separates Element zu selektieren, sodass sie sowohl für Suchergebnisdatensätze als auch für einzelne Produktseiten verfügbar ist.

Kann ich die gescrapten Daten als CSV statt als JSON speichern?

Ja. Das Skript schreibt beides: eine JSON-Datei für verschachtelte Struktur und eine CSV für Tabellenkalkulationen. Eine gemeinsame FIELDS-Liste steuert den CSV-Header und die Spaltenreihenfolge, damit sie mit den Dictionary-Schlüsseln abgestimmt bleibt. Sie können die Datensätze auch direkt in eine Datenbank laden, wenn Sie das bevorzugen.

Wie vermeide ich es, beim Scrapen von Zoro gesperrt zu werden?

Halten Sie Ihre anfragenrate pro IP niedrig, fügen Sie eine Verzögerung zwischen Seiten hinzu und leiten Sie durch rotierende Residential-IPs, damit keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rotation, einen vertrauenswürdigen IP-Pool und CAPTCHA-Handling für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren sollten. Beobachten Sie die Statuscodes und ziehen Sie sich zurück, wenn Sie beginnen, Challenges zu sehen.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.