Costco-Produktdaten scrapenPreise, Artikel und Verfügbarkeit

Costco betreibt weltweit mehr als 800 Filialen, und derselbe Katalog ist auf costco.com als öffentliche Produktseiten und Suchergebnisse verfügbar. Preise, Artikelnummern, Bewertungen und Verfügbarkeitsstatus sind für jeden ohne Konto direkt auf der Seite zu lesen. Diese öffentlichen Daten sind ein klares Signal für Preisverfolgung, Wettbewerbsanalyse und Bestandsüberwachung, weshalb Händler, Analysten und Entwickler sie regelmäßig abrufen.

Diese Anleitung zeigt Ihnen, wie Sie Costco-Produktdaten mit Python scrapen. Sie erstellen einen kleinen, lauffähigen Scraper, der Costco-Such- und Produktseiten über die Crawling API abruft, für jedes Element einen sauberen Datensatz analysiert, die Paginierung über Suchergebnisse verwaltet und die Daten in JSON und CSV exportiert. Die gesamte Anleitung beschränkt sich auf öffentliche Produktdaten: Titel, Preise, Artikelnummern, Bewertungen und Verfügbarkeit, die jeder ohne Anmeldung auf einem Angebot sehen kann.

Was Sie erstellen werden

Ein Python-Skript, das eine Costco-Such-URL oder eine Produkt-URL entgegennimmt, die gerenderte Seite über die Crawling API abruft und für jedes Produkt einen strukturierten Datensatz extrahiert. Als laufendes Beispiel verwenden wir eine Sofas-Suche, dieselbe Kategorie wie in der früheren Anleitung, und lesen diese Felder:

• Title der Produktname, der auf der Angebotsseite oder Produktseite angezeigt wird.
• Price der aufgeführte Preis, wenn das Produkt einen anzeigt.
• Item number Costcos einmaliger Produktbezeichner, nützlich zur Bestandsverfolgung über mehrere Durchläufe.
• Rating die durchschnittliche Sternebewertung, aus der Produktkarte oder -seite gelesen.
• Availability das Auf-Lager- oder Nicht-auf-Lager-Signal auf der Produktseite.
• Product URL der Link zur Detailseite des Artikels.
• Image URL die Produktbildquelle.

Warum eine einfache Anfrage bei Costco scheitert

Wenn Sie einen einfachen HTTP-Client auf eine Costco-Such- oder Produkt-URL richten, erhalten Sie selten die gewünschten Daten. Zwei Dinge sprechen dagegen. Erstens rendern Costcos Seiten einen Großteil ihres Inhalts clientseitig: Die Website liefert eine schlanke Hülle und füllt das Produktraster und die Preisblöcke ein, sobald das JavaScript der Seite ausgeführt wird. Das anfängliche HTML fehlt oft die gewünschten Felder. Zweitens erkennt Costco automatisierten Traffic schnell. Datacenter-IP-Bereiche und Anfragemuster, die nicht wie ein echter Browser aussehen, werden mit einer Herausforderung, einer Zwischenseite oder einer direkten Sperre beantwortet, bevor Sie die Angebote überhaupt erreichen.

Ein funktionierender Costco-Scraper benötigt also zwei Dinge in einer einzigen Anfrage: einen Browser, der die Seite rendert, und eine IP, die die Seite als echten Käufer erkennt. Sie können das selbst mit einem Headless Browser und einem Pool von rotierenden Residential Proxies zusammenstellen, aber die Pflege dieses Stacks ist der Hauptaufwand. Die Crawling API kombiniert beides in einem einzigen Aufruf: Sie senden ihr die URL, sie rendert die Seite hinter einer vertrauenswürdigen Residential-IP, übernimmt Rotation und CAPTCHA-Lösung und gibt Ihnen fertiges HTML zum Parsen zurück.

Voraussetzungen

Bevor Sie mit dem Schreiben von Code beginnen, müssen einige Dinge bereitstehen. Keines davon nimmt lange in Anspruch.

Python-Grundkenntnisse. Sie sollten in der Lage sein, ein Python-Skript zu schreiben, auszuführen und Pakete mit pip zu installieren. Falls Sie neu in der Sprache sind, decken die offizielle Python-Dokumentation oder ein Einsteigerkurs das für dieses Tutorial vorausgesetzte Niveau ab.

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

Ein Crawlbase-Konto und Token. Registrieren Sie sich für ein kostenloses Konto, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token. Costcos Seiten sind JavaScript-intensiv, also verwenden Sie das JavaScript-Token für diese Anfragen. Das kostenlose Kontingent umfasst bis zu 20.000 Anfragen ohne Kreditkarte, was mehr als ausreichend ist, um diesen Scraper zu erstellen und zu testen. Behandeln Sie das Token wie ein Passwort und halten Sie es aus der Versionsverwaltung heraus.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit die 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 analysiert das zurückgegebene HTML, sodass Sie jedes Feld aus der Seite per CSS-Selektor extrahieren können.

python --version

python -m venv costco_env
source costco_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit costco_env\Scripts\activate anstelle der source-Zeile. Nachdem beide Bibliotheken installiert sind, erstellen Sie die Skriptdatei, die in der restlichen Anleitung aufgebaut wird:

touch costco_scraper.py

Die Costco-Seiten verstehen

Es gibt zwei Seitentypen, die es sich zu scrapen lohnt, und sie enthalten unterschiedliches Markup. Eine Suchergebnisseite wie https://www.costco.com/s?dept=All&keyword=sofas zeigt ein Raster von Produktkarten. Eine Produktseite wie https://www.costco.com/coddle-aria-fabric-sleeper-sofa.product.4000223041.html zeigt die vollständige Detailansicht für einen Artikel, einschließlich Beschreibung, Spezifikationen und Verfügbarkeit.

Bevor Sie Selektoren schreiben, öffnen Sie jede Seite in Ihrem Browser, klicken Sie mit der rechten Maustaste auf ein Produkt und wählen Sie Untersuchen. Auf der Suchseite umschließt Costco die Angebotsseite mit div[id="productList"] und gruppiert Artikel unter div[data-testid="Grid"]. Jede Karte zeigt den Titel in einem div mit einem data-testid, das mit Text_ProductTile_ beginnt, den Preis in einem, das mit Text_Price_ beginnt, die Bewertung unter Rating_ProductTile_, den Link in einem a[data-testid="Link"]-Anker und das Bild in einem img-Tag. Auf der Produktseite ist der Titel ein h1[automation-id="productName"], der Preis ein span[automation-id="productPriceOutput"] und die Bewertung ein div[itemprop="ratingValue"]. Das sind die Elemente, auf die Sie abzielen.

Schritt 1: Eine gerenderte Costco-Seite abrufen

Beginnen Sie damit, die fertige Seite abzurufen. Importieren Sie die Klasse CrawlingAPI, initialisieren Sie sie mit Ihrem Token, setzen Sie die Such-URL und fordern Sie sie an. Costco lädt sein Raster asynchron, also übergeben Sie die Optionen ajax_wait und page_wait, um der Seite Zeit zum Laden zu geben, bevor sie aufgezeichnet wird. Die Überprüfung des Statuscodes vor dem Parsen sorgt dafür, dass Fehler auffällig und nicht still auftreten.

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.costco.com/s?dept=All&keyword=sofas"
    html = crawl(search_url)
    print(html[:500] if html else "No HTML returned")

Die zwei Warteoptionen sind wichtig für ein Raster, das sich beim Laden der Seite füllt. ajax_wait weist die API an, auf das Ende asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden nach dem Laden an, sodass die spät gerenderten Karten erscheinen, bevor die Seite aufgezeichnet wird. Führen Sie das Skript aus und Sie sollten echtes Produkt-Markup sehen, keine Ladehülle. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Suchangebote mit BeautifulSoup analysieren

Mit dem gerenderten HTML laden Sie es in BeautifulSoup, suchen jede Produktkarte und lesen jedes Feld über seinen Selektor aus. Costco gruppiert Artikel unter div[id="productList"] > div[data-testid="Grid"], und jede Karte zeigt Titel, Preis, Bewertung, Link und Bild. Umschließen Sie die Schleife so, dass ein fehlendes Feld einen sauberen Fallback zurückgibt, anstatt den Durchlauf zum Absturz zu bringen.

from bs4 import BeautifulSoup
import re

def item_number_from_url(url):
    match = re.search(r"\.product\.(\d+)\.html", url or "")
    return match.group(1) if match else "N/A"

def scrape_search_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    products = []
    items = soup.select('div[id="productList"] > div[data-testid="Grid"]')
    for item in items:
        title_el = item.select_one('div[data-testid^="Text_ProductTile_"]')
        price_el = item.select_one('div[data-testid^="Text_Price_"]')
        rating_el = item.select_one('div[data-testid^="Rating_ProductTile_"] > div')
        link_el = item.select_one('a[data-testid="Link"]')
        image_el = item.find("img")

        product_url = link_el["href"] if link_el else "N/A"
        products.append({
            "title": title_el.get_text(strip=True) if title_el else "N/A",
            "price": price_el.get_text(strip=True) if price_el else "N/A",
            "item_number": item_number_from_url(product_url),
            "rating": rating_el["aria-label"] if rating_el and rating_el.has_attr("aria-label") else "N/A",
            "product_url": product_url,
            "image_url": image_el["src"] if image_el and image_el.has_attr("src") else "N/A",
        })
    return products

Jede Karte wird einem sauberen Dictionary zugeordnet. Der Titel kommt aus div[data-testid^="Text_ProductTile_"] und der Preis aus div[data-testid^="Text_Price_"], beide mit der ^=-Anfangsübereinstimmung, da Costco diese Test-IDs pro Produkt mit einem Suffix versieht. Die Bewertung wird aus dem aria-label des verschachtelten Bewertungs-div gelesen, das den lesbaren Text wie "Average rating is 4.65 out of 5 stars" enthält. Die Artikelnummer wird aus der Produkt-URL geparst, da Costco sie im Segment .product.NNNN.html kodiert, sodass Sie einen stabilen Bezeichner ohne einen separaten Selektor erhalten. Jedes Feld fällt auf "N/A" zurück, wenn es fehlt, was die Extraktion robust hält, da nicht jede Karte einen Preis oder eine Bewertung trägt.

Schritt 3: Paginierung über Suchseiten verwalten

Costco-Suchergebnisse erstrecken sich über mehrere Seiten, und die Website lädt jede mit einem &currentPage=-Parameter in der URL. Um eine vollständige Kategorie zu erfassen, fügen Sie diesen Parameter an und durchlaufen Sie die Seiten der Reihe nach, wobei Sie die Anfragen takten, damit Sie die Website nicht in einer engen Schleife belasten.

import time

def scrape_all_pages(base_url, total_pages):
    all_products = []
    for page_num in range(1, total_pages + 1):
        paginated_url = f"{base_url}&currentPage={page_num}"
        print(f"Scraping page {page_num}")
        html = crawl(paginated_url)
        if not html:
            break
        found = scrape_search_listings(html)
        if not found:
            break
        all_products.extend(found)
        time.sleep(2)
    return all_products

Der Abbruch bei leeren Ergebnissen stoppt Sie frühzeitig, wenn einer Kategorie die Seiten ausgehen, und das time.sleep(2) zwischen den Anfragen taktet den Durchlauf, damit Sie nicht für schnellen Traffic markiert werden. Setzen Sie total_pages auf die Anzahl der Ergebnisseiten, über die sich die Suche für Ihr Stichwort erstreckt.

Schritt 4: Eine einzelne Produktseite scrapen

Suchkarten geben Ihnen die Hauptfelder, aber die Produktseite enthält den Rest: die vollständige Beschreibung, die strukturierten Spezifikationen und das Verfügbarkeitssignal. Die Seite rendert genauso wie das Suchraster, also verwenden Sie den crawl-Helfer erneut und analysieren Sie die Detailselektoren.

def scrape_product_page(html, url):
    soup = BeautifulSoup(html, "html.parser")

    title_el = soup.select_one('h1[automation-id="productName"]')
    price_el = soup.select_one('span[automation-id="productPriceOutput"]')
    rating_el = soup.select_one('div[itemprop="ratingValue"]')
    desc_el = soup.select_one('div[id="product-tab1-espotdetails"]')
    image_el = soup.find("img", class_="thumbnail-image")
    stock_el = soup.select_one('div[automation-id="productInventoryStatus"]')

    specifications = {}
    for row in soup.select("div.product-info-description .row"):
        name = row.select_one(".spec-name")
        value = row.select_one("div:not(.spec-name)")
        if name and value:
            specifications[name.get_text(strip=True)] = value.get_text(strip=True)

    return {
        "title": title_el.get_text(strip=True) if title_el else "N/A",
        "price": price_el.get_text(strip=True) if price_el else "N/A",
        "item_number": item_number_from_url(url),
        "rating": rating_el.get_text(strip=True) if rating_el else "N/A",
        "availability": stock_el.get_text(strip=True) if stock_el else "N/A",
        "description": desc_el.get_text(strip=True) if desc_el else "N/A",
        "image_url": image_el["src"] if image_el and image_el.has_attr("src") else "N/A",
        "specifications": specifications,
    }

Die Produktseiten-Selektoren stammen direkt aus Costcos Detail-Markup. Der Titel ist ein h1[automation-id="productName"], der Preis ein span[automation-id="productPriceOutput"], die Bewertung ein div[itemprop="ratingValue"] und der Beschreibungsblock befindet sich unter div[id="product-tab1-espotdetails"]. Die Spezifikationsschleife geht durch jede .row in der Beschreibungstabelle, liest das Label aus .spec-name und kombiniert es mit dem benachbarten Wertefeld, sodass Sie ein sauberes Dictionary von Attributen wie Rahmenmaterial und Abmessungen erhalten. Die Verfügbarkeit wird aus dem Bestandsstatus-Block gelesen; verwenden Sie denselben item_number_from_url-Helfer, damit der Bezeichner mit den Suchdatensätzen konsistent bleibt.

Schritt 5: Das Skript zusammensetzen und JSON und CSV exportieren

Verbinden Sie jetzt das Abrufen, die Paginierung und die Parser in einem einzigen lauffähigen Skript und schreiben Sie die Datensätze sowohl in JSON als auch CSV, sodass Sie sie in ein Notebook oder eine Tabellenkalkulation laden können. Eine gemeinsame Feldliste hält die CSV-Spalten mit den Dictionary-Schlüsseln synchron.

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

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
FIELDS = ["title", "price", "item_number", "rating", "product_url", "image_url"]

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 item_number_from_url(url):
    match = re.search(r"\.product\.(\d+)\.html", url or "")
    return match.group(1) if match else "N/A"

def scrape_search_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    products = []
    items = soup.select('div[id="productList"] > div[data-testid="Grid"]')
    for item in items:
        title_el = item.select_one('div[data-testid^="Text_ProductTile_"]')
        price_el = item.select_one('div[data-testid^="Text_Price_"]')
        rating_el = item.select_one('div[data-testid^="Rating_ProductTile_"] > div')
        link_el = item.select_one('a[data-testid="Link"]')
        image_el = item.find("img")
        product_url = link_el["href"] if link_el else "N/A"
        products.append({
            "title": title_el.get_text(strip=True) if title_el else "N/A",
            "price": price_el.get_text(strip=True) if price_el else "N/A",
            "item_number": item_number_from_url(product_url),
            "rating": rating_el["aria-label"] if rating_el and rating_el.has_attr("aria-label") else "N/A",
            "product_url": product_url,
            "image_url": image_el["src"] if image_el and image_el.has_attr("src") else "N/A",
        })
    return products

def scrape_all_pages(base_url, total_pages):
    all_products = []
    for page_num in range(1, total_pages + 1):
        paginated_url = f"{base_url}&currentPage={page_num}"
        print(f"Scraping page {page_num}")
        html = crawl(paginated_url)
        if not html:
            break
        found = scrape_search_listings(html)
        if not found:
            break
        all_products.extend(found)
        time.sleep(2)
    return all_products

def export(rows, name="costco_products"):
    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():
    base_url = "https://www.costco.com/s?dept=All&keyword=sofas"
    products = scrape_all_pages(base_url, total_pages=5)
    export(products)

if __name__ == "__main__":
    main()

Führen Sie das vollständige Skript mit python costco_scraper.py aus. Es durchläuft die Suchseiten, analysiert eine Zeile pro Produkt und schreibt sowohl costco_products.json als auch costco_products.csv. Die gemeinsame Liste FIELDS hält die CSV-Spaltenreihenfolge mit den Dictionary-Schlüsseln synchron, sodass die beiden Exporte nie auseinanderlaufen. Um die Daten mit Beschreibungen, Spezifikationen und Verfügbarkeit anzureichern, übergeben Sie jede product_url an crawl und scrape_product_page aus Schritt 4.

So sieht die Ausgabe aus

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

[
  {
    "title": "Coddle Aria Fabric Sleeper Sofa with Reversible Chaise Gray",
    "price": "$1,299.99",
    "item_number": "4000223041",
    "rating": "Average rating is 4.65 out of 5 stars. Based on 1668 reviews.",
    "product_url": "https://www.costco.com/coddle-aria-fabric-sleeper-sofa-with-reversible-chaise-gray.product.4000223041.html",
    "image_url": "https://cdn.bfldr.com/U447IH35/at/nx2pbmjk76t8c5k4h3qpsg6/4000223041-847_gray_1.jpg"
  },
  {
    "title": "Larissa Fabric Chaise Sofa",
    "price": "$1,899.99",
    "item_number": "4000052035",
    "rating": "Average rating is 4.03 out of 5 stars. Based on 87 reviews.",
    "product_url": "https://www.costco.com/larissa-fabric-chaise-sofa.product.4000052035.html",
    "image_url": "https://cdn.bfldr.com/U447IH35/as/ck2h3n29gz2j6m7c9f7x4rhm/4000052035-847_gray_1"
  }
]

Ein Produktseiten-Durchlauf liefert einen reichhaltigeren Datensatz mit der Beschreibung, dem Verfügbarkeitssignal und einem Spezifikations-Dictionary von Attributen wie Rückenstil, Rahmenmaterial und Gesamtabmessungen, direkt aus der Detailtabelle extrahiert.

Entsperrt bleiben

Auch mit gehandhabtem Rendering beobachtet Costco Scraper-ähnlichen Traffic. Einige Gewohnheiten halten einen Durchlauf gesund, und sie gelten für jedes schwierige kommerzielle Ziel.

• Anfragen takten. Verteilen Sie Anfragen mit einer Verzögerung zwischen den Seiten, anstatt alles mit voller Geschwindigkeit zu crawlen. Planen Sie schwerere Jobs zu Nebenzeiten ein, um die Serverlast von Costco zu verringern.
• Auf Rotation setzen. Ein Pool von Residential IPs verteilt Anfragen auf viele echte Benutzeradressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist dies der Teil, den Sie richtig machen müssen.
• Nur das Benötigte behalten. Speichern Sie die Produktfelder, die Ihr Projekt benötigt, und verwerfen Sie den Rest. Überprüfen Sie Ihre Selektoren regelmäßig, damit der Scraper mit Markup-Änderungen Schritt hält.

Das umfassendere Handbuch zum Vermeiden von Blockierungen finden Sie unter So scrapen Sie Websites ohne Blockiert zu werden, und für weitere Informationen dazu, warum Rendering hier wichtig ist, empfiehlt sich So crawlen Sie JavaScript-Websites. Die gesammelten Daten fließen direkt in die Preisintelligenz-Arbeit ein, und die umfassenderen Muster übertragen sich auf andere Shops in diesem E-Commerce-Web-Scraping-Leitfaden.

Ist es legal, Costco zu scrapen?

Ob das Scrapen von Costco erlaubt ist, hängt von den Nutzungsbedingungen von Costco, Ihrer Gerichtsbarkeit und dem Verwendungszweck der Daten ab. Costcos Nutzungsbedingungen schränken den automatisierten Zugriff ein, sodass das Scrapen unabhängig davon, wie sorgfältig Ihr Tooling ist, gegen diese Bedingungen verstoßen kann. Keiner der hier vorgestellten Code ändert das; er macht lediglich den technischen Teil funktionsfähig. Lesen Sie Costcos Nutzungsbedingungen und seine robots.txt, und behandeln Sie beides als Grenze für das, was Sie sammeln. Für kommerzielle oder wettbewerbsorientierte Nutzung wird das rechtliche Bild komplizierter, und die Konsultation eines Rechtsexperten für Ihren spezifischen Fall ist ratsam.

Einige Grenzen, die es einzuhalten gilt. Sammeln Sie nur öffentliche Daten: die Titel, Preise, Artikelnummern, Bewertungen, Verfügbarkeit und Angebotslinks, die jeder auf einer Costco-Seite ohne Konto sehen kann. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie die Server von Costco nicht belasten, und vermeiden Sie personenbezogene Daten, einschließlich allem, was mit identifizierbaren Mitgliedern, Rezensenten oder Verkäufern in Verbindung steht, über das öffentlich aufgelistete hinaus. Wenn Sie die Daten kommerziell wiederverwenden möchten, holen Sie eine Genehmigung oder eine offizielle Vereinbarung ein, anstatt Stillschweigen als Zustimmung zu werten.

Diese Anleitung ist bewusst auf öffentliche Produkt- und Suchseiten beschränkt, denn das ist die Grenze, die die Arbeit vertretbar hält. Sie behandelt nichts hinter einem Login, keine Mitglieds- oder Bestelldaten, keine Preise, die nur für angemeldete Mitglieder angezeigt werden, und keinen Versuch, die Authentifizierung oder ein CAPTCHA zu umgehen, zu dem Sie nicht berechtigt sind. Wenn Ihr Projekt mehr als öffentliche Produktdaten benötigt, ist eine offizielle Datenvereinbarung oder ein Partnerprogramm der richtige Weg und kein clevererer Scraper.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keine Produkte von Costco zurück?

Costco rendert einen Großteil seines Produktrasters und der Preisblöcke clientseitig beim Laden der Seite, sodass eine rohe Anfrage oft eine Hülle zurückgibt, bei der die gewünschten Felder fehlen. Darüber hinaus fordert oder blockiert Costco Traffic, der nicht wie ein echter Browser aussieht. Das Rendern der Seite über die Crawling API hinter einer vertrauenswürdigen IP, mit den gesetzten Optionen ajax_wait und page_wait, löst beides, weshalb der Scraper hier seine Anfrage darüber leitet.

Welche Daten kann ich mit diesem Scraper von Costco extrahieren?

Aus Suchangeboten erhalten Sie Titel, Preis, Artikelnummer, Bewertung, Produkt-URL und Bild-URL für jede Karte. Von einer einzelnen Produktseite erhalten Sie zusätzlich die Beschreibung, die vollständige Spezifikationstabelle und das Verfügbarkeitssignal. Alle diese Daten sind öffentliche Produktdaten, die Sie in JSON oder CSV für die Analyse speichern können.

Wie scrape ich mehrere Seiten von Costco-Suchergebnissen?

Costco lädt jede Suchseite mit einem &currentPage=-Parameter in der URL. Fügen Sie diesen Parameter an und iterieren Sie über die Seitenzahlen, analysieren Sie jede Seite der Reihe nach und brechen Sie frühzeitig ab, wenn eine Seite keine Produkte zurückgibt. Fügen Sie zwischen den Anfragen eine kurze Verzögerung hinzu, damit Sie den Durchlauf takten, anstatt die Website zu belasten.

Wie erhalte ich die Costco-Artikelnummer?

Costco kodiert die Artikelnummer in der Produkt-URL im Segment .product.NNNN.html. Der Scraper extrahiert sie mit einem kleinen Regex-Helfer, sodass Sie sowohl aus Suchkarten als auch von Produktseiten einen stabilen Bezeichner erhalten, ohne auf einen separaten seitenbasierten Selektor angewiesen zu sein, der sich ändern könnte.

Benötige ich das JavaScript-Token, um Costco zu scrapen?

Ja. Costcos Seiten benötigen JavaScript, um das Produktraster, die Preise und die Verfügbarkeit zu rendern, also verwenden Sie das JavaScript-Token und die Warteoptionen beim Aufruf der Crawling API. Das kostenlose Kontingent umfasst bis zu 20.000 Anfragen zum Erstellen und Testen, und Sie können die aktuellen Preise auf der Preisseite einsehen.

Wie vermeide ich Blockierungen beim Scrapen von Costco?

Halten Sie Ihre Anfragerate pro IP niedrig, fügen Sie zwischen den Seiten eine Verzögerung hinzu und leiten Sie Anfragen über 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 verlangsamen Sie, wenn Sie beginnen, Herausforderungen 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.