Samsung-Produkte scrapenSpezifikationen und Preise mit JavaScript

Samsungs Storefront ist einer der übersichtlicheren öffentlichen Kataloge für Consumer-Electronics im Netz. Jedes Smartphone-Listing trägt einen Modellnamen, einen Preis, Kundenbewertungen und eine kurze Spezifikationsliste, die jeder sieht, der die Seite öffnet. Das macht sie zu einer nützlichen Quelle für Preisverfolgung, Wettbewerbsforschung und Trendanalyse: Der öffentliche Katalog zeigt Ihnen, was Samsung verkauft, zu welchem Preis und wie Käufer das Produkt bewerten.

Diese Anleitung zeigt Ihnen, wie Sie Samsung-Produkte scrapen können, mit Node.js, unter Verwendung der Crawlbase Crawling API zum Abrufen der gerenderten Seite und cheerio zum Herausziehen jedes Feldes aus dem HTML. Die gesamte Anleitung beschränkt sich auf öffentliche Katalogdaten: den Produktnamen, das Modell, den Preis, die Bewertung, die Anzahl der Rezensionen, Schlüsselspezifikationen und die Produkt-URL, die der Storefront jedem Besucher zeigt. Nichts davon berührt Konten, Bestellungen oder irgendetwas hinter einem Login.

Was Sie bauen werden

Ein kleines Node.js-Skript, das eine Samsung-Listing-Seite anfordert, vollständig gerendertes HTML zurückbekommt, jede Produktkarte durchläuft und einen sauberen Datensatz pro Telefon als JSON schreibt. Jeder Datensatz erfasst:

• Produktname. Die Modellreihe, wie auf der Karte angezeigt, zum Beispiel Galaxy S24 Ultra.
• Modell und Variante. Die für dieses Produkt aufgeführten Speicher- und Konfigurationsoptionen.
• Preis. Der Katalogpreis, den der Storefront für das Listing anzeigt.
• Bewertung. Der durchschnittliche Kundenbewertungswert.
• Rezensionsanzahl. Auf wie vielen Bewertungen dieser Wert basiert.
• Schlüsselspezifikationen. Die kurzen Spezifikations-Aufzählungspunkte auf der Karte, wie Displaygröße, Kamera und Akku.
• Produkt-URL. Der Link zur vollständigen Produktseite.

Warum eine einfache Anfrage bei Samsung scheitert

Wenn Sie einen einfachen HTTP-Client auf eine Samsung-Listing-URL richten, erhalten Sie selten den Katalog, den Sie im Browser sehen. Der Storefront rendert einen Großteil seiner Inhalte clientseitig: Das Produktraster, Preise und Bewertungen laden über JavaScript, nachdem das anfängliche HTML ankam. Eine rohe Anfrage gibt die Seiten-Shell zurück, wobei die Datenstellen noch leer sind, sodass cheerio nichts zu parsen findet.

Dazu überwachen große Einzelhandelsseiten automatisierten Datenverkehr. Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden herausgefordert oder gedrosselt, bevor sie das nützliche Markup erreichen. Ein funktionierender Samsung-Scraper benötigt daher zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die der Storefront als echter Besucher erscheint. Sie können das selbst mit einem Headless-Browser wie Puppeteer plus einem Pool von rotierenden residentiellen Proxys zusammenstellen, aber das Zusammenführen und Gesundhalten davon ist der größte Teil der Arbeit. Die Crawling API faltet beides in einen einzigen Aufruf: Sie senden ihr die URL, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zurück, das Sie parsen können.

Voraussetzungen

Vor dem Schreiben von Code müssen einige Dinge eingerichtet sein. Keines davon dauert lange.

Node.js 18 oder höher. Überprüfen Sie Ihre Version mit node --version. Falls Sie es nicht haben, installieren Sie das aktuelle LTS von nodejs.org. Node lässt Sie JavaScript außerhalb des Browsers ausführen und gibt Ihnen npm für die Installation von Paketen.

Grundlegendes JavaScript. Sie sollten damit vertraut sein, ein Skript zu schreiben, es vom Terminal aus auszuführen und Pakete mit npm zu installieren. Grundkenntnisse über Promises und then-Ketten lassen den Code sauber lesen.

Ein Crawlbase-Konto und Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token von der Konto-Dokumentationsseite. Verwenden Sie das JavaScript (JS)-Token für den Samsung-Storefront. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es daher aus der Versionskontrolle heraus.

Projekt einrichten

Erstellen Sie einen Ordner, initialisieren Sie ein Projekt und installieren Sie die beiden Abhängigkeiten, die der Scraper benötigt.

mkdir scrape-samsung-products && cd scrape-samsung-products
npm init -y

npm install crawlbase cheerio

Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und cheerio ist ein schneller, schlanker Parser, der Ihnen jQuery-ähnliche Selektoren über das zurückgegebene HTML gibt, ohne Browser. Erstellen Sie eine index.js-Datei im Ordner; dort kommt der Code unten hin.

Schritt 1: Die gerenderte Seite abrufen

Beginnen Sie damit, den fertigen Katalog zu holen. Importieren Sie CrawlingAPI aus dem crawlbase-Paket, initialisieren Sie es mit Ihrem JS-Token und fordern Sie die Samsung-Listing-URL an. Die beiden Warteoptionen sind hier wichtig: ajax_wait weist die API an, auf das Fertigladen asynchroner Inhalte zu warten, und page_wait hält eine festgelegte Anzahl von Millisekunden nach dem Laden an, damit das spät rendernde Raster erscheint, bevor die Seite erfasst wird. Das Überprüfen des Statuscodes vor dem Parsen hält Fehler laut statt still.

const { CrawlingAPI } = require("crawlbase");

const api = new CrawlingAPI({ token: "YOUR_CRAWLBASE_JS_TOKEN" });
const samsungProductsURL =
  "https://www.samsung.com/levant/smartphones/all-smartphones/";

api
  .get(samsungProductsURL, { ajax_wait: true, page_wait: 10000 })
  .then((response) => {
    if (response.statusCode === 200) {
      console.log(response.body.slice(0, 500));
    } else {
      throw new Error(`Failed to fetch HTML. Status: ${response.statusCode}`);
    }
  })
  .catch(console.error);

Führen Sie es mit node index.js aus und Sie sollten echtes Katalog-Markup sehen, keine abgespeckte Shell. Zehn Sekunden page_wait ist für ein so schweres Raster großzügig; reduzieren Sie den Wert, sobald Sie bestätigt haben, dass die Produkte vorhanden sind. Diese Ausgabe bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben. Wenn Sie mehr Hintergrund dazu brauchen, warum clientseitig gerenderte Seiten diesen Schritt benötigen, lesen Sie wie man JavaScript-Websites crawlt.

Schritt 2: Die Produktfelder mit cheerio parsen

Mit gerendertem HTML in der Hand laden Sie es in cheerio und gehen das Produktraster durch. Das Muster lautet: Finden Sie die sich wiederholende Produktkarte, dann ziehen Sie für jede Karte die gewünschten Felder per CSS-Selektor heraus. Samsungs Storefront legt jede Karte vorhersehbar aus, sodass Sie den Produktnamen, die Farbe, Varianten, Bewertung, Spezifikationen und URL einzelnen Selektoren zuordnen können. Die unten stehenden Selektoren stammen direkt aus dem Live-Katalog-Markup.

const cheerio = require("cheerio");

function scrapeProducts(html) {
  const $ = cheerio.load(html);
  const products = [];

  $(".js-pfv2-content-wrap .js-pfv2-product-card").each((_, element) => {
    const card = $(element);

    const name = card
      .find(".pd03-product-card__product-name-text")
      .text()
      .trim();

    const color = card
      .find(".option-selector-v2__color-name-text-in")
      .text()
      .trim();

    const variants = card
      .find(".option-selector-v2__size-text")
      .map((_, el) => $(el).text().trim())
      .get();

    const rating = card
      .find(".rating__point span:last-child")
      .text()
      .trim();

    const reviewCount = card
      .find(".rating__count")
      .text()
      .replace(/[^0-9]/g, "");

    const specifications = card
      .find(".pd03-product-card__spec-list .pd03-product-card__spec-item")
      .map((_, el) => $(el).text().trim())
      .get();

    const url = card
      .find(".pd03-product-card__product-image-link")
      .attr("href");

    products.push({
      name,
      model: [color, ...variants].filter(Boolean).join(", "),
      rating,
      reviewCount,
      specifications: specifications.join(", "),
      url: url && (url.startsWith("http") ? url : `https://www.samsung.com${url}`),
    });
  });

  return products;
}

Jedes Feld wird einem Selektor zugeordnet, den Sie selbst überprüfen können: Klicken Sie mit der rechten Maustaste auf das Element auf einem Live-Samsung-Listing, wählen Sie Untersuchen und lesen Sie die Klasse vom markierten Knoten ab. .text() liest das sichtbare Label; .attr("href") liest den Link. Das .map().get()-Paar wandelt eine Menge übereinstimmender Elemente (die Varianten und Spezifikations-Aufzählungspunkte) in ein einfaches Array um. Da Hrefs auf dem Storefront manchmal relativ sind, stellt der Code die Domain voran, wenn die URL nicht bereits mit http beginnt. Mehr zur Erstellung robuster Selektoren finden Sie im Leitfaden zu XPath und CSS-Selektoren.

Schritt 3: Das vollständige Skript zusammenstellen

Verbinden Sie nun den Abruf und den Parser: Fordern Sie die Seite an, übergeben Sie den Body an scrapeProducts, protokollieren Sie das Ergebnis und schreiben Sie es in eine JSON-Datei. Dies ist das vollständige, kopierfähige Skript.

const { CrawlingAPI } = require("crawlbase");
const cheerio = require("cheerio");
const fs = require("fs");

const api = new CrawlingAPI({ token: "YOUR_CRAWLBASE_JS_TOKEN" });
const samsungProductsURL =
  "https://www.samsung.com/levant/smartphones/all-smartphones/";

function scrapeProducts(html) {
  const $ = cheerio.load(html);
  const products = [];
  const totalResults = $(".js-pfv2-result-total-count").text().trim();

  $(".js-pfv2-content-wrap .js-pfv2-product-card").each((_, element) => {
    const card = $(element);
    const color = card
      .find(".option-selector-v2__color-name-text-in")
      .text()
      .trim();
    const variants = card
      .find(".option-selector-v2__size-text")
      .map((_, el) => $(el).text().trim())
      .get();
    const url = card
      .find(".pd03-product-card__product-image-link")
      .attr("href");

    products.push({
      name: card.find(".pd03-product-card__product-name-text").text().trim(),
      model: [color, ...variants].filter(Boolean).join(", "),
      rating: card.find(".rating__point span:last-child").text().trim(),
      reviewCount: card.find(".rating__count").text().replace(/[^0-9]/g, ""),
      specifications: card
        .find(".pd03-product-card__spec-list .pd03-product-card__spec-item")
        .map((_, el) => $(el).text().trim())
        .get()
        .join(", "),
      url: url && (url.startsWith("http") ? url : `https://www.samsung.com${url}`),
    });
  });

  return { totalResults, products };
}

api
  .get(samsungProductsURL, { ajax_wait: true, page_wait: 10000 })
  .then((response) => {
    if (response.statusCode !== 200) {
      throw new Error(`Failed to fetch HTML. Status: ${response.statusCode}`);
    }
    const data = scrapeProducts(response.body);
    console.log(data);
    fs.writeFileSync("samsung-scraped.json", JSON.stringify(data, null, 2));
  })
  .catch(console.error);

Führen Sie node index.js erneut aus. Das Skript ruft den gerenderten Katalog ab, parst jede Produktkarte, druckt das Ergebnis und speichert es in samsung-scraped.json. Das Feld totalResults erfasst die Anzahl, die der Storefront anzeigt, damit Sie prüfen können, wie viele Produkte die Seite gemeldet hat im Vergleich zu wie viele Karten Sie geparst haben.

Wie die Ausgabe aussieht

Jeder Eintrag ist ein Telefon mit den Feldern, die sauberen Schlüsseln zugeordnet sind. Ein gekürztes Beispiel der JSON-Datei:

{
  "totalResults": "42 results",
  "products": [
    {
      "name": "Galaxy S24 Ultra",
      "model": "Titanium Yellow, 256 GB, 512 GB, 1 TB",
      "rating": "4.3",
      "reviewCount": "128",
      "specifications": "Industry-leading hardware meets world-changing AI, Made with titanium. Built to last, 200MP high-resolution photography",
      "url": "https://www.samsung.com/levant/smartphones/galaxy-s24-ultra/"
    },
    {
      "name": "Galaxy A04s",
      "model": "Black, 64 GB, 128 GB",
      "rating": "5.0",
      "reviewCount": "17",
      "specifications": "6.5\" Infinity-V Display, 50MP Camera, 5000mAh Battery",
      "url": "https://www.samsung.com/levant/smartphones/galaxy-a/galaxy-a04s-black-64gb-sm-a047fzkgmeb/"
    }
  ]
}

Von hier aus geht JSON direkt in eine Datenbank oder ein Notebook. Wenn Sie lieber eine flache Datei für eine Tabellenkalkulation hätten, ordnen Sie das Array Zeilen zu und schreiben Sie stattdessen eine CSV; der Feldsatz bleibt derselbe.

Über Kategorien und Seiten skalieren

Eine Katalogseite ist der Baustein; ein echter Job sammelt mehrere. Samsung veröffentlicht separate Listing-URLs pro Region und Kategorie (alle Smartphones, Faltbare, Tablets usw.), und längere Listen paginieren oder laden beim Scrollen weitere Karten. Um zu skalieren, halten Sie eine Liste von Listing-URLs und führen denselben Fetch-and-Parse über jede aus, dann verketten Sie die Ergebnisse.

const listingURLs = [
  "https://www.samsung.com/levant/smartphones/all-smartphones/",
  "https://www.samsung.com/levant/smartphones/galaxy-z/",
];

async function scrapeAll(urls) {
  const all = [];
  for (const url of urls) {
    const response = await api.get(url, { ajax_wait: true, page_wait: 10000 });
    if (response.statusCode === 200) {
      all.push(...scrapeProducts(response.body).products);
    }
    await new Promise((r) => setTimeout(r, 2000));
  }
  return all;
}

Das kurze setTimeout zwischen Anfragen verteilt den Lauf, damit Sie den Storefront nicht bombardieren. Da jedes Listing dasselbe Karten-Layout teilt, funktioniert der eine scrapeProducts-Parser über alle hinweg. Wenn eine Kategorie ein Infinite-Scroll-Raster statt diskreter Seiten verwendet, kann die Crawling API die Seite vor der Erfassung für Sie scrollen, sodass die zusätzlichen Karten im HTML landen, das Sie parsen.

Nicht blockiert bleiben

Die Crawling API übernimmt den schwierigen Teil des Nicht-Blockiert-Werdens: Sie rendert jede Seite in einem echten Browser und leitet die Anfrage durch rotierende residentielle IPs, sodass Ihr Datenverkehr wie gewöhnliche Besucher aussieht statt wie eine einzelne hammernde Adresse. Halten Sie Ihre eigene Anfragerate vernünftig, verteilen Sie Batches mit einer kurzen Verzögerung wie oben gezeigt und beobachten Sie die Statuscodes, damit Sie zurückweichen, wenn Herausforderungen auftreten. Wenn Sie Ihren eigenen Stack mit Puppeteer aufbauen, sind die Proxy-Rotation und IP-Gesundheit die Teile, in die Sie investieren sollten. Eine umfassendere Behandlung finden Sie unter wie man Websites scrapt, ohne blockiert zu werden.

Ist es legal, Samsung zu scrapen?

Das Scrapen öffentlicher Katalogdaten birgt weit weniger Risiken als das Scrapen von Inhalten hinter einem Login, aber die Antwort hängt immer noch davon ab, was Sie sammeln, wie Sie es verwenden und welche Regeln die Website hat. Diese Anleitung ist bewusst auf öffentliche Produktinformationen beschränkt: den Modellnamen, Preis, Bewertung, Rezensionsanzahl, Schlüsselspezifikationen und die Produkt-URL, die Samsungs Storefront jedem Besucher ohne Konto zeigt. Das sind die Daten, die ein Käufer sieht, und das Sammeln für Preisverfolgung oder Forschung ist der vertretbare Fall.

Bevor Sie irgendetwas in größerem Umfang ausführen, lesen Sie Samsungs Nutzungsbedingungen und überprüfen Sie seine robots.txt, um zu sehen, welche Pfade die Website Crawlern freizulassen bittet, und respektieren Sie diese Anfragen. Halten Sie Ihre Anfragerate bescheiden, damit Sie die Server nicht belasten. Diese Anleitung deckt nichts hinter einem Login, persönliche oder Kontodaten, Bestellverlauf oder urheberrechtlich geschützte Medien wie Produktfotografie, die Sie weitergeben würden, ab. Diese sind hier außerhalb des Geltungsbereichs, und das Erreichen dieser Daten verstößt gegen Samsungs Bedingungen.

Für kommerzielle oder volumenstarke Nutzung bevorzugen Sie offizielle Kanäle. Wenn Sie Massenkataloginformationen oder Preisdaten für den Weiterverkauf oder die Verteilung benötigen, sind Samsungs Partner- und Entwicklerprogramme der richtige Weg, und die Einholung von Genehmigungen oder eines Daten-Feeds ist sauberer als das Scrapen in großem Maßstab. Wenn der öffentliche Katalog wirklich die einzige Quelle für das ist, was Sie benötigen, beschränken Sie die Arbeit auf diese öffentlichen Daten, respektieren Sie die angegebenen Regeln der Website und konsultieren Sie einen Rechtsanwalt, wenn Ihr Anwendungsfall kommerziell oder unklar ist.

Häufig gestellte Fragen

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

Weil der Storefront sein Produktraster clientseitig mit JavaScript rendert. Eine rohe HTTP-Anfrage kommt mit der Seiten-Shell zurück, aber die Katalogstellen noch leer, da Produkte, Preise und Bewertungen erst auffüllen, nachdem die Skripte der Seite in einem Browser ausgeführt wurden. Das JS-Token der Crawling API rendert die Seite zuerst, sodass die Karten beim Parsen durch cheerio vorhanden sind.

Brauche ich das normale Token oder das JS-Token für Samsung?

Verwenden Sie das JS-Token. Das normale Token ruft statisches HTML ab, was auf Samsungs Storefront das Produktraster leer lässt. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass Name, Modell, Preis, Bewertung, Rezensionsanzahl, Spezifikationen und URL alle vorhanden sind, wenn Sie parsen.

Welche Daten kann ich von einer Samsung-Listing-Seite scrapen?

Öffentliche Katalogfelder: den Produktnamen, Modell- und Variantenoptionen, Preis, durchschnittliche Bewertung, Rezensionsanzahl, die Schlüsselspezifikations-Aufzählungspunkte auf jeder Karte und die Produkt-URL. Diese Anleitung beschränkt sich auf diese öffentlichen Daten. Sie deckt keine Kontoinformationen, Bestellverlauf oder irgendetwas hinter einem Login ab.

Meine cheerio-Selektoren geben leere Zeichenketten zurück. Was hat sich geändert?

Höchstwahrscheinlich Samsungs Markup. Klassennamen wie js-pfv2-product-card, pd03-product-card__product-name-text und rating__point ändern sich ohne Ankündigung, sodass Selektoren, die letzten Monat funktioniert haben, brechen können. Untersuchen Sie ein Live-Listing in den Entwicklertools Ihres Browsers erneut und aktualisieren Sie die Selektoren. Regelmäßige Selektor-Wartung ist bei jedem Produktionsscraper normal.

Kann ich viele Samsung-Seiten scrapen, ohne blockiert zu werden?

Ja, in vernünftigem Maße. Die Crawling API rotiert durch residentielle IPs und rendert jede Seite in einem echten Browser, sodass einzelne Anfragen wie echte Besuche aussehen. Halten Sie Ihre Pro-IP-Rate niedrig, fügen Sie eine kurze Verzögerung zwischen Anfragen hinzu, wie im Skalierungsabschnitt gezeigt, und variieren Sie Ihre Ziele, anstatt einen Pfad in einer Schleife zu durchlaufen. Beobachten Sie die Statuscodes und weichen Sie zurück, wenn Sie beginnen, Herausforderungen zu sehen.

Bietet Samsung einen offiziellen Weg, Produktdaten zu erhalten?

Für kommerzielle oder volumenstarke Nutzung sind Samsungs Partner- und Entwicklerprogramme der richtige Kanal, und die Anforderung einer Genehmigung oder eines Daten-Feeds ist sauberer als das Scrapen in großem Maßstab. Greifen Sie nur dann auf Scraping zurück, wenn der öffentliche Katalog wirklich die einzige Quelle für die öffentlichen Felder ist, die Sie benötigen, und beschränken Sie die Arbeit auf diese öffentlichen Daten.

MA

Muhammad Atif

Senior Full Stack Developer · Crawlbase

Senior Full Stack Developer bei Crawlbase, der die Plattform aufbaut und über Scraping-Architektur, Proxys und Datenpipelines schreibt.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.