Costco ist eines der größten Lagerunternehmen der Welt mit über 800 Lagern weltweit und Millionen von Kunden. Das Inventar reicht von Lebensmitteln bis hin zu Elektronik, Haushaltswaren und Kleidung. Angesichts einer so großen Produktpalette könnten die Produktdaten von Costco in den Augen von Unternehmen, Forschern und Entwicklern Gold wert sein.

Sie können Daten von Costco extrahieren, um Einblicke in Produktpreise, Produktverfügbarkeit, Kundenfeedback usw. zu erhalten. Mithilfe der Daten, die Sie von Costco abrufen, können Sie fundierte Entscheidungen treffen und Markttrends verfolgen. In diesem Artikel erfahren Sie, wie Sie Costco-Produktdaten mit dem Scraping-Tool extrahieren. Crawlbase Crawling API und Python.

Lassen Sie uns direkt in den Prozess einsteigen!

Inhaltsverzeichnis

  1. Warum Produktdaten von Costco abrufen?
  2. Wichtige Datenpunkte zum Extrahieren von Costco
  3. Crawlbase Crawling API für Costco Scraping
  • Crawlbase Python-Bibliothek
  1. Einrichten Ihrer Python-Umgebung
  • Installieren von Python und erforderlichen Bibliotheken
  • Auswahl einer IDE
  1. Scraping von Costco-Sucheinträgen
  • Überprüfen des HTML auf Selektoren
  • Schreiben des Costco Search Listings Scrapers
  • Umgang mit Paginierung
  • Speichern von Daten in einer JSON-Datei
  • Code vervollständigen
  1. Scraping von Costco-Produktseiten
  • Überprüfen des HTML auf Selektoren
  • Schreiben des Costco-Produktseiten-Scrapers
  • Speichern von Daten in einer JSON-Datei
  • Code vervollständigen
  1. Fazit
  2. Häufig gestellte Fragen (FAQ)

Warum Produktdaten von Costco abrufen?

Costco ist für seine große Auswahl an qualitativ hochwertigen Produkten zu niedrigen Preisen bekannt und daher bei Millionen beliebt. Die Produktdaten von Costco können für viele Zwecke verwendet werden, darunter Preisvergleiche, Marktforschung, Bestandsverwaltung und Produktanalysen. Durch den Zugriff auf diese Daten können Unternehmen Produkttrends überwachen, Preisstrategien verfolgen und Kundenpräferenzen verstehen.

Egal, ob Sie ein App-Entwickler sind, ein Geschäftsinhaber, der Marktforschung betreibt, oder einfach nur neugierig auf Produktpreise sind, das Scraping von Costco kann äußerst nützlich sein. Durch das Extrahieren von Produktinformationen wie Preis, Verfügbarkeit und Produktbeschreibung können Sie fundiertere Entscheidungen treffen oder über automatisierte Systeme verfügen, die Sie in Echtzeit auf dem Laufenden halten.

In den nächsten Abschnitten erfahren Sie mehr über die wichtigsten zu berücksichtigenden Datenpunkte und erfahren Schritt für Schritt, wie Sie einen Scraper zum Abrufen der Produktdaten von Costco einrichten.

Wichtige Datenpunkte zum Extrahieren von Costco

Wenn Sie Costco nach Produktdaten durchsuchen, möchten Sie sich darauf konzentrieren, nützliche Informationen zu erhalten, um fundierte Entscheidungen treffen zu können. Hier sind die wichtigsten Datenpunkte, die Sie berücksichtigen sollten:

Wichtige Punkte zum Extrahieren von Costco-Produktdaten
  • Produktname: Der Produktname ist wichtig für die Identifizierung und Organisation von Artikeln.
  • Preis: Der Preis jedes Produkts hilft beim Preisvergleich und der Verfolgung von Preisänderungen im Laufe der Zeit.
  • Produktbeschreibung*: Detaillierte Beschreibungen geben Einblick in die Funktionen und Vorteile jedes Artikels.
  • Bewertungen und Rezensionen: Das Sammeln von Kundenrezensionen und Sternebewertungen liefert wertvolles Feedback zur Produktqualität und Kundenzufriedenheit.
  • Bild-URL: Das Produktbild dient als visuelle Referenz und für Marketingzwecke.
  • Verfügbarkeit: Das Produktbild eignet sich gut für visuelle Referenzen und Marketingzwecke.
  • SKU (Lagerhaltungseinheit): Eindeutige Produktkennungen wie SKUs sind für die Bestandsverfolgung und Datenverwaltung wichtig.

Sobald Sie diese Datenpunkte haben, können Sie eine Produktdatenbank aufbauen, die Ihre Geschäftsanforderungen wie Marktforschung, Bestandsverwaltung und Wettbewerbsanalyse unterstützt. Als Nächstes sehen wir uns an, wie Crawlbase Crawling API kann beim Abwracken von Costco helfen.

Crawlbase Crawling API für Costco Scraping

Crawlbase Crawling API macht das Scraping von Costco-Websites super einfach und schnell. Die Costco-Website verwendet dynamische Inhalte, was bedeutet, dass einige Produktdaten über JavaScript geladen werden. Das macht das Scraping schwieriger, aber Crawlbase Crawling API rendert die Seite wie ein echter Browser.

Hier ist der Grund Crawlbase Crawling API ist eine gute Wahl, um bei Costco Geld abzukratzen:

  • Verarbeitet dynamische Inhalte: Es verarbeitet Seiten mit hohem JavaScript-Aufkommen, sodass alle Daten geladen und zum Scraping zugänglich sind.
  • IP-Rotation: Um eine Sperrung durch Costco zu vermeiden, Crawlbase übernimmt die IP-Rotation für Sie, sodass Sie sich keine Gedanken über Ratenbegrenzungen oder Sperren machen müssen.
  • High Performance: Mit Crawlbasekönnen Sie große Datenmengen schnell und effizient scrapen und so Zeit und Ressourcen sparen.
  • Anpassbare Anfragen: Sie können benutzerdefinierte Header und Cookies festlegen oder sogar das Anforderungsverhalten Ihren Anforderungen entsprechend steuern.

Mit diesen Vorteilen Crawlbase Crawling API vereinfacht den gesamten Prozess und ist damit eine perfekte Lösung zum Extrahieren von Produktdaten von Costco. Im nächsten Abschnitt richten wir eine Python-Umgebung für das Costco-Scraping ein.

Crawlbase Python-Bibliothek

Crawlbase verfügt über eine Python-Bibliothek, die Web Scraping deutlich vereinfacht. Diese Bibliothek benötigt zur Authentifizierung ein Zugriffstoken. Sie können ein Token erhalten, nachdem ein Profil erstellen auf Crawlbase.

Hier ist eine Beispielfunktion, die die Verwendung der Crawlbase Crawling API um Anfragen zu senden:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
von Crawlbase importieren CrawlingAPI

# Initialisieren Crawlbase API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({ 'Zeichen': 'IHR_CRAWLBASE_TOKEN' })

def Crawlbase-Anfrage erstellen(URL):
    Antwort = crawling_api.get(URL)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        html_content = Antwort['Körper'].dekodieren('utf-8')
        Rückkehr HTML-Inhalt
    sonst:
        drucken(f"Fehler beim Abrufen der Seite. Crawlbase Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine Präsentation

Hinweis: Crawlbase bietet zwei Arten von Token an:

  • Normales Token für statische Sites.
  • JavaScript (JS)-Token für dynamische oder browserbasierte Anfragen.

Zum Scraping dynamischer Websites wie Costco benötigen Sie das JS-Token. Crawlbase bietet 1,000 kostenlose Anfragen zum Einstieg. Für diese Testversion ist keine Kreditkarte erforderlich. Weitere Informationen finden Sie im Crawlbase Crawling API Dokumentation.

Einrichten Ihrer Python-Umgebung

Bevor Sie mit dem Scraping bei Costco beginnen, müssen Sie eine geeignete Python-Umgebung einrichten. Dazu müssen Sie Python, die erforderlichen Bibliotheken und eine IDE zum Schreiben und Testen Ihres Codes installieren.

Installieren von Python und erforderlichen Bibliotheken

  1. Installieren Sie Python: Laden Sie Python herunter und installieren Sie es vom offizielle Python-Website. Wählen Sie die neueste stabile Version für Ihr Betriebssystem.
  2. Erforderliche Bibliotheken installieren: Nach der Installation von Python benötigen Sie einige Bibliotheken, mit denen Sie arbeiten können Crawlbase Crawling API und um den Scraping-Prozess abzuwickeln. Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung und führen Sie die folgenden Befehle aus:
1
2
pip installieren beautifulsoap4
pip installieren crawlbase
  • **beautifulsoup4**: BeautifulSoup erleichtert das Parsen und Navigieren durch die HTML-Struktur der Webseiten.
  • **crawlbase**: Crawlbase ist die offizielle Bibliothek von Crawlbase die Sie zur Verbindung mit ihrer API verwenden.

Auswahl einer IDE

Die Wahl der richtigen integrierten Entwicklungsumgebung (IDE) kann das Programmieren einfacher und effizienter machen. Hier sind einige beliebte Optionen:

  • VS-Code: Einfach und leicht, vielseitig einsetzbar, kostenlos mit Python-Erweiterungen.
  • PyCharm: Eine robuste Python-IDE mit vielen integrierten Tools für die professionelle Entwicklung.
  • Jupyter Notizbücher: Gut zum Ausführen von Codes mit einer interaktiven Einstellung, insbesondere für Datenprojekte.

Nachdem Sie nun Python und die erforderlichen Bibliotheken installiert und eine IDE ausgewählt haben, können Sie mit dem Scraping von Costco-Produktdaten beginnen. Im nächsten Abschnitt erklären wir Schritt für Schritt, wie Sie Costco-Suchlisten scrapen.

So scrapen Sie Costco-Sucheinträge

Nachdem wir die Python-Umgebung eingerichtet haben, können wir mit dem Scraping der Costco-Sucheinträge beginnen. In diesem Abschnitt erfahren Sie, wie Sie das HTML auf Selektoren prüfen, einen Scraper schreiben und Crawlbase und BeautifulSoup, kümmern sich um die Paginierung und speichern die extrahierten Daten in einer JSON-Datei.

Überprüfen des HTML auf Selektoren

Um die Costco-Produktlisten effizient zu durchsuchen, müssen wir die HTML-Struktur überprüfen. Folgendes müssen Sie normalerweise finden:

Screenshot der HTML-Struktur für Costco-Suchlisten
  1. Produkttitel: Gefunden in einem <div> mit data-testid beginnen mit Text_ProductTile_.
  2. Produktpreis: Befindet sich in einem <div> mit data-testid beginnen mit Text_Price_.
  3. Produktbewertung: Gefunden in einem div mit data-testid beginnen mit Rating_ProductTile_.
  4. Produkt-URL: Eingebettet in eine <a> tag mit data-testid="Link".
  5. Bild-URL: Gefunden in einem <img> tag unter dem src Attribut.

Darüber hinaus sind Produktlisten enthalten div[id="productList"], mit Elementen gruppiert unter div[data-testid="Grid"].

Schreiben des Costco Search Listings Scrapers

Crawlbase Crawling API mehrere bereitstellen Parameter die Sie damit verwenden können. Mit CrawlbaseMit dem JS-Token können Sie dynamisches Laden von Inhalten auf Costco verwalten. Die ajax_wait mit einem page_wait Parameter können verwendet werden, um der Seite Zeit zum Laden zu geben.

Schreiben wir einen Scraper, der den Produkttitel, den Preis, die Produkt-URL und die Bild-URL von der Costco-Suchergebnisseite sammelt, indem er Crawlbase Crawling API und BeautifulSoup.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe

# Initialisieren Crawlbase API
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

# Funktion zum Abrufen von HTML-Inhalten aus den Costco-Suchergebnissen
def Suchlisten abrufen(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine Präsentation

# Produktlisten von einer Seite scrapen
def scrape_costco_search_listings(URL):
    html_content = Suchlisten abrufen(URL)
    if HTML-Inhalt:
        Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
        Produktliste = []
        Produktartikel = Suppe.Auswahl('div[id="productList"] > div[data-testid="Grid"]')

        für  ausgleichen  in Produkt_Artikel:
            Titel = Element.Wählen Sie eins aus('div[data-testid^="Text_ProductTile_"]').text.strip() if Element.Wählen Sie eins aus('div[data-testid^="Text_ProductTile_"]') sonst 'N / A'
            Preis = Artikel.Wählen Sie einen Artikel aus('div[data-testid^="Text_Price_"]').text.strip() if Element.Wählen Sie eins aus('div[data-testid^="Text_Price_"]') sonst 'N / A'
            Bewertung = Artikel.Wählen Sie einen aus('div[data-testid^="Rating_ProductTile_"] > div')[„Arien-Etikett“] if Element.Wählen Sie eins aus('div[data-testid^="Rating_ProductTile_"] > div') sonst 'N / A'
            Produkt-URL = Artikel.Wählen Sie einen aus('a[data-testid="Link"]')['href'] if Element.Wählen Sie eins aus('a[data-testid="Link"]') sonst 'N / A'
            Bild-URL = Element.finden('img')['Quelle'] if Artikel.finden('img') sonst 'N / A'

            produkt_liste.anhängen({
                ‚Titel‘: Titel,
                'Preis': Preis,
                'Bewertung': Bewertung,
                'Produkt-URL': Produkt-URL,
                'Bild-URL': Bild-URL
            })
        Rückkehr Produktliste
    sonst:
        Rückkehr []

# Beispielverwendung
URL = „https://www.costco.com/s?dept=All&keyword=sofas“
Produkte = scrape_costco_search_listings(URL)
drucken(Produkte)

In diesem Code:

  • Suchlisten abrufen (): Diese Funktion verwendet die Crawlbase API zum Abrufen des HTML-Inhalts von der Costco-Suchlistenseite.
  • scrape_costco_search_listings(): Diese Funktion analysiert das HTML mit BeautifulSoup, um Produktdetails wie Titel, Preis, Produkt-URL und Bild-URL zu extrahieren.

Umgang mit Paginierung

Die Suchergebnisse von Costco können sich über mehrere Seiten erstrecken. Um alle Produkte zu erfassen, müssen wir die Seitennummerierung handhaben. Costco verwendet die &currentPage= Parameter in der URL, um verschiedene Seiten zu laden.

So handhaben Sie die Seitennummerierung:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def Alle Seiten auslesen(Basis-URL, Gesamtseiten):
    alle_produkte = []

    für  Seitennummer in Angebot(1, Gesamtseitenzahl + 1):
        paginierte_URL = f"{base_url}¤tPage={Seitenzahl}"
        drucken(f"Seite scrapen {Seitenzahl}")

        Produkte = scrape_costco_search_listings(paginierte_URL)
        alle_produkte.erweitern(Produkte)

    Rückkehr alle_produkte

# Beispielverwendung
Gesamtseiten = 5  # Passen Sie es basierend auf der Anzahl der zu scrapenden Seiten an
Basis-URL = „https://www.costco.com/s?dept=All&keyword=sofas“
alle_Produkte = alle_Seiten_abrufen(Basis-URL, Gesamtseiten)
drucken(f"Insgesamt verschrottete Produkte: {len(alle_produkte)}")

Dieser Code durchsucht mehrere Seiten mit Suchergebnissen, indem er die &currentPage= Parameter zur Basis-URL.

So speichern Sie Daten in einer JSON-Datei

Nachdem Sie die Produktdaten gesammelt haben, ist es wichtig, sie für die spätere Verwendung zu speichern. So können Sie die Produktlisten in einer JSON-Datei speichern:

1
2
3
4
5
6
7
8
9
importieren JSON

def in JSON speichern(Daten, Dateiname=„costco_product_listings.json“):
    mit XNUMXh geöffnet(Dateiname, 'w') as f:
        json.dump(Daten, f, Einzug=2)
    drucken(f"Daten gespeichert in {Dateiname}")

# Beispielverwendung
save_to_json(alle_Produkte)

Diese Funktion schreibt die gesammelten Produktdetails in eine costco_product_listings.json Datei.

Code vervollständigen

Hier ist der vollständige Code zum Scrapen der Costco-Suchlisten, zum Verwalten der Paginierung und zum Speichern der Daten in einer JSON-Datei:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren JSON

# Initialisieren Crawlbase API
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

# HTML-Inhalt abrufen
def Suchlisten abrufen(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine Präsentation

# Produktlisten von einer Seite scrapen
def scrape_costco_search_listings(URL):
    html_content = Suchlisten abrufen(URL)
    if HTML-Inhalt:
        Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
        Produktliste = []
        Produktartikel = Suppe.Auswahl('div[id="productList"] > div[data-testid="Grid"]')

        für  ausgleichen  in Produkt_Artikel:
            Titel = Element.Wählen Sie eins aus('div[data-testid^="Text_ProductTile_"]').text.strip() if Element.Wählen Sie eins aus('div[data-testid^="Text_ProductTile_"]') sonst 'N / A'
            Preis = Artikel.Wählen Sie einen Artikel aus('div[data-testid^="Text_Price_"]').text.strip() if Element.Wählen Sie eins aus('div[data-testid^="Text_Price_"]') sonst 'N / A'
            Bewertung = Artikel.Wählen Sie einen aus('div[data-testid^="Rating_ProductTile_"] > div')[„Arien-Etikett“] if Element.Wählen Sie eins aus('div[data-testid^="Rating_ProductTile_"] > div') sonst 'N / A'
            Produkt-URL = Artikel.Wählen Sie einen aus('a[data-testid="Link"]')['href'] if Element.Wählen Sie eins aus('a[data-testid="Link"]') sonst 'N / A'
            Bild-URL = Element.finden('img')['Quelle'] if Artikel.finden('img') sonst 'N / A'

            produkt_liste.anhängen({
                ‚Titel‘: Titel,
                'Preis': Preis,
                'Bewertung': Bewertung,
                'Produkt-URL': Produkt-URL,
                'Bild-URL': Bild-URL
            })
        Rückkehr Produktliste
    sonst:
        Rückkehr []

# Alle Seiten scrapen
def Alle Seiten auslesen(Basis-URL, Gesamtseiten):
    alle_produkte = []
    für  Seitennummer in Angebot(1, Gesamtseitenzahl + 1):
        paginierte_URL = f"{base_url}¤tPage={Seitenzahl}"
        drucken(f"Seite scrapen {Seitenzahl}")
        Produkte = scrape_costco_search_listings(paginierte_URL)
        alle_produkte.erweitern(Produkte)
    Rückkehr alle_produkte

# Daten in einer JSON-Datei speichern
def in JSON speichern(Daten, Dateiname=„costco_product_listings.json“):
    mit XNUMXh geöffnet(Dateiname, 'w') as f:
        json.dump(Daten, f, Einzug=2)
    drucken(f"Daten gespeichert in {Dateiname}")

# Beispielverwendung
Basis-URL = „https://www.costco.com/s?dept=All&keyword=sofas“
Gesamtseiten = 5
alle_Produkte = alle_Seiten_abrufen(Basis-URL, Gesamtseiten)
save_to_json(alle_Produkte)

Beispielausgabe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
[
  {
    „Titel“: "Coddle Aria Schlafsofa aus Stoff mit wendbarer Chaiselongue in Grau",
    "Preis": "$ 1,299.99",
    "Bewertung": „Die durchschnittliche Bewertung liegt bei 4.65 von 5 Sternen. Basierend auf 1668 Bewertungen.“,
    "Produkt-URL": „https://www.costco.com/coddle-aria-fabric-sleeper-sofa-with-reversible-chaise-gray.product.4000223041.html“,
    "Bild URL": "https://cdn.bfldr.com/U447IH35/at/nx2pbmjk76t8c5k4h3qpsg6/4000223041-847_gray_1.jpg?auto=webp&format=jpg&width=350&height=350&fit=bounds&canvas=350,350"
  },
  {
    „Titel“: "Larissa Stoff-Chaiselongue-Sofa",
    "Preis": "$ 1,899.99",
    "Bewertung": „Die durchschnittliche Bewertung liegt bei 4.03 von 5 Sternen. Basierend auf 87 Bewertungen.“,
    "Produkt-URL": „https://www.costco.com/larissa-fabric-chaise-sofa.product.4000052035.html“,
    "Bild URL": "https://cdn.bfldr.com/U447IH35/as/ck2h3n29gz2j6m7c9f7x4rhm/4000052035-847_gray_1?auto=webp&format=jpg&width=350&height=350&fit=bounds&canvas=350,350"
  },
  {
    „Titel“: "Ridgewin Ledersofa mit elektrischer Liegefunktion",
    "Preis": "$ 1,499.99",
    "Bewertung": „Die durchschnittliche Bewertung liegt bei 4.63 von 5 Sternen. Basierend auf 1377 Bewertungen.“,
    "Produkt-URL": „https://www.costco.com/ridgewin-leather-power-reclining-sofa.product.4000079113.html“,
    "Bild URL": "https://cdn.bfldr.com/U447IH35/as/xsmmcftqhmgws76mr625rgx/1653285-847__1?auto=webp&format=jpg&width=350&height=350&fit=bounds&canvas=350,350"
  },
  {
    „Titel“: „Thomasville Langdon Stoffsofa mit Ottomane mit Stauraum“,
    "Preis": "$ 1,499.99",
    "Bewertung": „Die durchschnittliche Bewertung liegt bei 4.52 von 5 Sternen. Basierend auf 1981 Bewertungen.“,
    "Produkt-URL": „https://www.costco.com/thomasville-langdon-fabric-section-with-storage-ottoman.product.4000235345.html“,
    "Bild URL": "https://cdn.bfldr.com/U447IH35/at/p3qmw24rtkkrtf77hmxvmpg/4000235345-847__1.jpg?auto=webp&format=jpg&width=350&height=350&fit=bounds&canvas=350,350"
  },
  .... mehr
]

So scrapen Sie Costco-Produktseiten

Nachdem wir nun erläutert haben, wie man Costco-Suchlisten ausliest, besteht der nächste Schritt darin, detaillierte Produktinformationen aus einzelnen Produktseiten zu extrahieren. In diesem Abschnitt erfahren Sie, wie Sie das HTML auf Selektoren untersuchen, einen Scraper für Costco-Produktseiten schreiben und die Daten in einer JSON-Datei speichern.

Überprüfen des HTML auf Selektoren

Um einzelne Costco-Produktseiten zu scrapen, müssen wir die HTML-Struktur der Seite untersuchen. Folgendes müssen Sie normalerweise finden:

Screenshot der HTML-Struktur der Costco-Produktseite
  1. Produkttitel: Der Titel befindet sich in einem <h1> Tag mit dem Attribut automation-id="productName".
  2. Produktpreis: Der Preis liegt innerhalb einer <span> Tag mit dem Attribut automation-id="productPriceOutput".
  3. Produktbewertung: Die Bewertung befindet sich innerhalb einer <div> Tag mit dem Attribut itemprop="ratingValue".
  4. Produktbeschreibung*: Beschreibungen befinden sich in einem <div> Tag mit der ID product-tab1-espotdetails.
  5. Bilder: Die Produktbild-URL wird extrahiert aus einem <img> tag mit der klasse thumbnail-image durch das Ergreifen der src Attribut.
  6. Spezifikationen: Die Spezifikationen werden in einem strukturierten HTML gespeichert, typischerweise in Zeilen in <div> Tags mit Klassen wie .spec-name, und die Werte befinden sich in Geschwistern <div> Stichworte.

Schreiben des Costco-Produktseiten-Scrapers

Wir erstellen nun einen Scraper, der detaillierte Informationen aus einzelnen Produktseiten, Produkttitel, Preis, Beschreibung und Bildern extrahiert. Der Scraper verwendet Crawlbase Crawling API ajax_wait mit einem page_wait Parameter zum Abrufen des Inhalts und BeautifulSoup zum Parsen des HTML.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe

# Initialisieren Crawlbase API
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

# Funktion zum Abrufen des HTML-Inhalts der Produktseite
def Produktseite abrufen(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine Präsentation

# Funktion zum Scrapen von Costco-Produktdetails
def Scrape_Costco_Produktseite(URL):
    html_content = Produktseite abrufen(URL)

    if HTML-Inhalt:
        Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')

        Titel = Suppe.select_one('h1[automation-id="Produktname"]').text.strip() if Suppe.Wähle eine('h1[automation-id="Produktname"]') sonst 'N / A'
        Preis = Suppe.select_one('span[automation-id="Produktpreisausgabe"]').text.strip() if Suppe.Wähle eine('span[automation-id="Produktpreisausgabe"]') sonst 'N / A'
        Bewertung = Suppe.select_one('div[itemprop="Bewertungswert"]').text.strip() if Suppe.Wähle eine('div[itemprop="Bewertungswert"]') sonst 'N / A'
        Beschreibung = Suppe.select_one('div[id="product-tab1-espotdetails"]').text.strip() if Suppe.Wähle eine('div[id="product-tab1-espotdetails"]') sonst 'N / A'
        Bilder-URL = Suppe.Finden('img', Klasse_='Miniaturbild')['Quelle'] if Suppe.find('img', Klasse_='Miniaturbild') sonst 'N / A'
        Spezifikationen = {row.select_one('.Spezifikationsname').text.strip(): Zeile.eine_Auswahl('div:nicht(.spec-name)').text.strip() für  Reihe in Suppe.Auswählen(„div.Produktinfo-Beschreibung .row“) if Zeile.Eine_Auswahl('.Spezifikationsname')}

        Produktdetails = {
            ‚Titel‘: Titel,
            'Preis': Preis,
            'Bewertung': Bewertung,
            'Bezeichnung': Beschreibung,
            'Bilder_URL': Bilder-URL,
            'Spezifikationen': Spezifikationen,
        }

        Rückkehr Produktdetails
    sonst:
        Rückkehr {}

# Beispielverwendung
produkt_url = „https://www.costco.com/example-product-page.html“
Produktdetails = scrape_costco_product_page(Produkt-URL)
drucken(Produktdetails)

In diesem Code:

  • **fetch_product_page()**: Diese Funktion verwendet Crawlbase um den HTML-Inhalt von einer Costco-Produktseite abzurufen.
  • **scrape_costco_product_page()**: Diese Funktion verwendet BeautifulSoup, um das HTML zu analysieren und relevante Details wie Produkttitel, Preis, Beschreibung und Bild-URL zu extrahieren.

Speichern von Daten in einer JSON-Datei

Sobald wir die Produktdetails extrahiert haben, können wir sie zur späteren Verwendung in einer JSON-Datei speichern.

1
2
3
4
5
6
7
8
9
10
importieren JSON

# Funktion zum Speichern von Produktdetails in einer JSON-Datei
def Produkt in JSON speichern(Daten, Dateiname=„costco_product_details.json“):
    mit XNUMXh geöffnet(Dateiname, 'w') as f:
        json.dump(Daten, f, Einzug=2)
    drucken(f"Daten gespeichert in {Dateiname}")

# Beispielverwendung
save_product_to_json(Produktdetails)

Dieser Code schreibt die gesammelten Produktdetails in eine costco_product_details.json Datei.

Code vervollständigen

Hier ist der vollständige Code, der Details der Costco-Produktseite abruft und speichert, mit Crawlbase und BeautifulSoup:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren JSON

# Initialisieren Crawlbase API
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

# HTML-Inhalt der Produktseite abrufen
def Produktseite abrufen(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine Präsentation

# Produktdetails von einer Costco-Produktseite scrapen
def Scrape_Costco_Produktseite(URL):
    html_content = Produktseite abrufen(URL)

    if HTML-Inhalt:
        Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')

        Titel = Suppe.select_one('h1[automation-id="Produktname"]').text.strip() if Suppe.Wähle eine('h1[automation-id="Produktname"]') sonst 'N / A'
        Preis = Suppe.select_one('span[automation-id="Produktpreisausgabe"]').text.strip() if Suppe.Wähle eine('span[automation-id="Produktpreisausgabe"]') sonst 'N / A'
        Bewertung = Suppe.select_one('div[itemprop="Bewertungswert"]').text.strip() if Suppe.Wähle eine('div[itemprop="Bewertungswert"]') sonst 'N / A'
        Beschreibung = Suppe.select_one('div[id="product-tab1-espotdetails"]').text.strip() if Suppe.Wähle eine('div[id="product-tab1-espotdetails"]') sonst 'N / A'
        Bilder-URL = Suppe.Finden('img', Klasse_='Miniaturbild')['Quelle'] if Suppe.find('img', Klasse_='Miniaturbild') sonst 'N / A'
        Spezifikationen = {row.select_one('.Spezifikationsname').text.strip(): Zeile.eine_Auswahl('div:nicht(.spec-name)').text.strip() für  Reihe in Suppe.Auswählen(„div.Produktinfo-Beschreibung .row“) if Zeile.Eine_Auswahl('.Spezifikationsname')}

        Produktdetails = {
            ‚Titel‘: Titel,
            'Preis': Preis,
            'Bewertung': Bewertung,
            'Bezeichnung': Beschreibung,
            'Bilder_URL': Bilder-URL,
            'Spezifikationen': Spezifikationen,
        }

        Rückkehr Produktdetails
    sonst:
        Rückkehr {}

# Produktdetails in einer JSON-Datei speichern
def Produkt in JSON speichern(Daten, Dateiname=„costco_product_details.json“):
    mit XNUMXh geöffnet(Dateiname, 'w') as f:
        json.dump(Daten, f, Einzug=2)
    drucken(f"Daten gespeichert in {Dateiname}")

# Beispielverwendung
produkt_url = „https://www.costco.com/coddle-aria-fabric-sleeper-sofa-with-reversible-chaise-gray.product.4000223041.html“
Produktdetails = scrape_costco_product_page(Produkt-URL)
save_product_to_json(Produktdetails)

Mit diesem Code können Sie jetzt einzelne Costco-Produktseiten scrapen und detaillierte Informationen wie Produkttitel, Preise, Beschreibungen und Bilder in einem strukturierten Format speichern.

Beispielausgabe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
  „Titel“: "Coddle Aria Schlafsofa aus Stoff mit wendbarer Chaiselongue in Grau",
  "Preis": "- -.- -",
  "Bewertung": "4.7",
  „Beschreibung“: "[ProductDetailsESpot_Tab1]\n\n\nCostco Direct-Ersparnisse\nKaufen Sie mehrere Costco Direct-Artikel in derselben Bestellung, um zusätzliche Ersparnisse zu erhalten. Die Artikel müssen an dieselbe Adresse geliefert werden, um Ersparnisse zu erhalten.\n\nKaufen Sie 2 Artikel, sparen Sie 100 $\nKaufen Sie 3 Artikel, sparen Sie 200 $\nKaufen Sie 4 Artikel, sparen Sie 300 $\nKaufen Sie 5 oder mehr Artikel, sparen Sie 400 $\nSolange der Vorrat reicht. Nur online. Maximal 2 Einlösungen pro Mitglied. Costco Direct-Ersparnisse können mit anderen Aktionen kombiniert werden.",
  "Bilder-URL": "https://cdn.bfldr.com/U447IH35/as/x8sjfsx359hh3w273f285x97/4000223041-847_gray_1?auto=webp&amp;format=jpg&width=150&height=150&fit=bounds&canvas=150,150",
  "Spezifikationen": {
    "Zurück Stil": "Kissenrücken",
    "Marke": "Verhätscheln",
    „Costco Direkt“: „Costco Direkt“,
    "Entwurf": "Stationär",
    "Eigenschaften": "Cabrio",
    "Rahmenmaterial": "Holz",
    "Stückzahl": "2 Stück",
    "Anzahl der USB-A-Anschlüsse": "1 Anschluss",
    "Anzahl der USB-C-Anschlüsse": "1 Anschluss",
    "Orientierung": "Reversibel",
    "Gesamtmaße (Schnitt): B x L x H": „37.4 Zoll x 89.4 Zoll x 37.4 Zoll.“,
    „Gesamtschnittgewicht“: „300.3 Pfund.“,
    „Sitzplatzkapazität“: "4 Personen",
    "Stil": "Übergangsweise",
    "Polstermaterial": "Stoff"
  }
}

Optimieren Sie Costco Scraper mit Crawlbase

Das Scraping von Produktdaten von Costco kann ein leistungsstarkes Tool zur Verfolgung von Preisen, Produktverfügbarkeit und Markttrends sein. Mit Crawlbase Crawling API und BeautifulSoup können Sie den Prozess automatisieren und die Daten zur Analyse im JSON speichern.

Folgen Sie dieser Anleitung, um einen Scraper für Ihre Anforderungen zu erstellen, sei es für die Konkurrenzanalyse, Recherche oder Bestandsverfolgung. Achten Sie nur darauf, die Nutzungsbedingungen der Website einzuhalten. Wenn Sie das Scraping von anderen E-Commerce-Plattformen ausprobieren möchten, können Sie die folgenden umfassenden Anleitungen lesen.

📜 Wie man Amazon scrapt
📜 Wie man Walmart scrapt
📜 So scrapen Sie AliExpress
📜 Wie man Flipkart scrapt
📜 Wie man Etsy scrapt

Bei Fragen oder Anregungen steht Ihnen unser Support-Team steht Ihnen jederzeit zur Verfügung, um Sie bei Ihrem Web Scraping-Vorhaben zu unterstützen. Viel Glück bei Ihrem Scraping-Vorhaben!

Häufig gestellte Fragen (FAQ)

Das Scraping von Costco oder anderen Websites muss verantwortungsvoll und im Rahmen der rechtlichen Richtlinien der Website erfolgen. Überprüfen Sie stets die Nutzungsbedingungen der Website, um sicherzustellen, dass Sie die Daten scrapen dürfen. Scrapen Sie nicht zu aggressiv, um eine Überlastung der Server zu vermeiden. Verwenden Sie Tools wie Crawlbase Das System beachtet Ratenbegrenzungen und verwaltet die IP-Rotation und kann Ihnen dabei helfen, Ihre Scraping-Aktivitäten innerhalb akzeptabler Grenzen zu halten.

F. Warum verwenden Crawlbase Crawling API für die Abschaffung von Costco?

Crawlbase Crawling API ist für die Verarbeitung komplexer Websites konzipiert, die JavaScript verwenden, wie beispielsweise Costco. Viele Websites laden Inhalte dynamisch, was das Funktionieren herkömmlicher Scraping-Methoden erschwert. Crawlbase Umgeht diese Einschränkungen, indem JavaScript gerendert und das vollständige HTML der Seite bereitgestellt wird. Dies erleichtert das Scraping der benötigten Daten. Außerdem verwaltet es Proxys und rotiert IPs, um Blockierungen beim Scraping großer Datenmengen zu vermeiden.

F: Welche Daten kann ich mit diesem Scraper von Costco extrahieren?

Mit diesem Scraper können Sie wichtige Datenpunkte von Costco-Produktseiten extrahieren, wie etwa Produktnamen, Preise, Beschreibungen, Bewertungen und Bild-URLs. Sie können auch Produktseitenlinks erfassen und die Paginierung handhaben, um mehrere Seiten mit Suchlisten effizient zu durchsuchen. Diese Daten können in einem strukturierten Format wie JSON gespeichert werden, um einen einfachen Zugriff und eine einfache Analyse zu ermöglichen.