Comment scraper les produits Samsungspécifications et prix avec JavaScript

La boutique en ligne de Samsung est l'un des catalogues publics d'électronique grand public les plus propres sur le web. Chaque annonce de smartphone porte un nom de modèle, un prix, des évaluations clients et une fiche technique courte, tous visibles pour quiconque ouvre la page. Cela en fait une source utile pour le suivi des prix, la recherche concurrentielle et l'analyse des tendances : le catalogue public vous dit ce que Samsung vend, à quel prix et comment les acheteurs l'évaluent.

Ce guide vous montre comment scraper les produits Samsung avec Node.js, en utilisant l'API Crawling Crawlbase pour récupérer la page rendue et cheerio pour extraire chaque champ du HTML. L'ensemble du tutoriel reste limité aux données du catalogue public : le nom du produit, le modèle, le prix, la note, le nombre d'avis, les spécifications clés et l'URL du produit que la boutique affiche à chaque visiteur. Rien ici ne touche aux comptes, commandes ou quoi que ce soit derrière une connexion.

Ce que vous allez construire

Un petit script Node.js qui demande une page d'annonce Samsung, reçoit du HTML entièrement rendu, boucle sur chaque carte produit et écrit un enregistrement propre par téléphone en JSON. Chaque enregistrement capture :

• Nom du produit. La ligne de modèle telle qu'affichée sur la carte, par exemple Galaxy S24 Ultra.
• Modèle et variante. Les options de stockage et de configuration listées pour ce produit.
• Prix. Le prix catalogue affiché par la boutique pour l'annonce.
• Note. Le score moyen des évaluations clients.
• Nombre d'avis. Le nombre d'évaluations sur lesquelles ce score est basé.
• Spécifications clés. Les puces de spécifications courtes sur la carte, comme la taille d'écran, l'appareil photo et la batterie.
• URL du produit. Le lien vers la page complète du produit.

Pourquoi une requête simple échoue sur Samsung

Si vous pointez un client HTTP basique sur une URL d'annonce Samsung, vous obtenez rarement le catalogue que vous voyez dans un navigateur. La boutique rend une grande partie de son contenu côté client : la grille de produits, les prix et les notes se chargent via JavaScript après l'arrivée du HTML initial. Une requête brute renvoie la coquille de la page avec les emplacements de données encore vides, donc cheerio ne trouve rien à analyser.

En plus, les grands sites de vente au détail surveillent le trafic automatisé. Les adresses IP de centres de données et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur sont challengés ou limités avant d'atteindre le balisage utile. Un scraper Samsung fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rend réellement la page, et une adresse IP que la boutique interprète comme un visiteur réel. Vous pouvez construire cela vous-même avec un navigateur headless comme Puppeteer et un pool de proxies résidentiels rotatifs, mais les assembler et les maintenir en bon état représente l'essentiel du travail. L'API Crawling combine les deux en un seul appel : vous lui envoyez l'URL, elle rend la page derrière une IP de confiance, et renvoie du HTML terminé à analyser.

Prérequis

Quelques éléments doivent être en place avant d'écrire du code. Aucun ne prend beaucoup de temps.

Node.js 18 ou supérieur. Vérifiez votre version avec node --version. Si vous ne l'avez pas, installez la LTS actuelle depuis nodejs.org. Node vous permet d'exécuter JavaScript en dehors du navigateur et vous donne npm pour installer des packages.

JavaScript de base. Vous devez être à l'aise pour écrire un script, l'exécuter depuis le terminal et installer des packages avec npm. Une connaissance pratique des promesses et des chaînes then rendra le code lisible.

Un compte Crawlbase et un token. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token depuis la page des docs du compte. Utilisez le token JavaScript (JS) pour la boutique Samsung. Traitez le token comme un mot de passe : il authentifie vos requêtes, gardez-le hors du contrôle de version.

Configurer le projet

Créez un dossier, initialisez un projet et installez les deux dépendances dont le scraper a besoin.

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

npm install crawlbase cheerio

Deux dépendances font le travail : crawlbase est le client officiel pour l'API Crawling, et cheerio est un parser rapide et léger qui vous donne des sélecteurs de style jQuery sur le HTML renvoyé sans navigateur attaché. Créez un fichier index.js dans le dossier ; c'est là que va le code ci-dessous.

Étape 1 : Récupérer la page rendue

Commencez par obtenir le catalogue terminé. Importez CrawlingAPI depuis le package crawlbase, initialisez-le avec votre token JS et demandez l'URL d'annonce Samsung. Les deux options d'attente comptent ici : ajax_wait indique à l'API d'attendre la fin du chargement du contenu asynchrone, et page_wait maintient un nombre fixe de millisecondes après le chargement pour que la grille à rendu tardif apparaisse avant la capture de la page. Vérifier le code de statut avant d'analyser rend les échecs visibles plutôt que silencieux.

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);

Exécutez-le avec node index.js et vous devriez voir de vraies balises de catalogue, pas une coquille allégée. Dix secondes de page_wait est généreux pour une grille aussi lourde ; réduisez-le une fois que vous confirmez que les produits sont présents. Cette sortie confirme que le rendu fonctionne avant d'écrire un seul sélecteur. Si vous souhaitez plus de contexte sur la raison pour laquelle les pages côté client ont besoin de cette étape, voir comment crawler des sites web JavaScript.

Étape 2 : Analyser les champs produit avec cheerio

Avec le HTML rendu en main, chargez-le dans cheerio et parcourez la grille de produits. Le schéma est : trouver la carte produit répétitive, puis pour chaque carte extraire les champs voulus par sélecteur CSS. La boutique de Samsung dispose chaque carte de manière prévisible, vous pouvez donc mapper le nom du produit, la couleur, les variantes, la note, les spécifications et l'URL vers des sélecteurs individuels. Les sélecteurs ci-dessous viennent directement du balisage du catalogue en direct.

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;
}

Chaque champ est mappé à un sélecteur que vous pouvez vérifier vous-même : faites un clic droit sur l'élément sur une vraie annonce Samsung, choisissez Inspecter, et lisez la classe sur le nœud mis en évidence. .text() lit le label visible ; .attr("href") lit le lien. La paire .map().get() transforme un ensemble d'éléments correspondants (les variantes et les puces de spécifications) en un tableau simple. Comme les hrefs sur la boutique sont parfois relatifs, le code préfixe le domaine quand l'URL ne commence pas déjà par http. Pour plus d'informations sur la construction de sélecteurs robustes, voir le guide sur les sélecteurs XPath et CSS.

Étape 3 : Assembler le script complet

Reliez maintenant la récupération et le parser : demandez la page, passez le corps à scrapeProducts, consignez le résultat et écrivez-le dans un fichier JSON. Voici le script complet, prêt à copier-coller.

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);

Exécutez à nouveau node index.js. Le script récupère le catalogue rendu, analyse chaque carte produit, imprime le résultat et le sauvegarde dans samsung-scraped.json. Le champ totalResults capture le compte que la boutique affiche pour que vous puissiez vérifier combien de produits la page a signalé par rapport au nombre de cartes que vous avez analysées.

À quoi ressemble la sortie

Chaque entrée est un téléphone avec les champs mappés vers des clés propres. Un exemple tronqué du fichier JSON :

{
  "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/"
    }
  ]
}

À partir de là, le JSON s'intègre directement dans une base de données ou un notebook. Si vous préférez un fichier plat pour un tableur, mappez le tableau en lignes et écrivez un CSV à la place ; le jeu de champs reste identique.

Mise à l'échelle sur les catégories et les pages

Une page de catalogue est le bloc de construction. Un vrai travail en collecte plusieurs. Samsung publie des URL d'annonces distinctes par région et catégorie (tous-smartphones, pliables, tablettes, etc.), et les listes plus longues paginent ou chargent davantage de cartes en faisant défiler. Pour mettre à l'échelle, gardez une liste d'URL d'annonces et exécutez le même fetch-and-parse sur chacune, puis concaténez les résultats.

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;
}

Le court setTimeout entre les requêtes cadence l'exécution pour ne pas marteler la boutique. Comme chaque annonce partage la même mise en page de carte, l'unique parser scrapeProducts fonctionne sur toutes. Si une catégorie utilise une grille à défilement infini plutôt que des pages discrètes, l'API Crawling peut faire défiler la page pour vous avant la capture, de sorte que les cartes supplémentaires atterrissent dans le HTML que vous analysez.

Rester non bloqué

L'API Crawling gère la partie difficile pour ne pas être bloqué : elle rend chaque page dans un vrai navigateur et route la requête via des IP résidentielles rotatives, de sorte que votre trafic ressemble à des visiteurs ordinaires plutôt qu'à une seule adresse qui martèle. Maintenez un débit de requêtes raisonnable, cadencez les lots avec un court délai comme indiqué ci-dessus, et surveillez les codes de statut pour reculer quand des challenges apparaissent. Si vous construisez votre propre stack avec Puppeteer à la place, la rotation des proxies et la santé des IP sont les parties à soigner. Pour un traitement plus large, lisez comment scraper des sites web sans être bloqué.

Est-il légal de scraper Samsung ?

Scraper des données de catalogue public comporte bien moins de risques que scraper du contenu derrière une connexion, mais la réponse dépend encore de ce que vous collectez, de comment vous l'utilisez et des règles du site. Ce guide est délibérément limité aux informations publiques sur les produits : le nom du modèle, le prix, la note, le nombre d'avis, les spécifications clés et l'URL du produit que la boutique de Samsung affiche à chaque visiteur sans compte. Ce sont les données qu'un acheteur voit, et les collecter pour le suivi des prix ou la recherche est le cas défendable.

Avant de lancer quoi que ce soit en volume, lisez les conditions d'utilisation de Samsung et vérifiez son robots.txt pour voir quels chemins le site demande aux crawlers de laisser tranquilles, et honorez ces demandes. Maintenez un débit de requêtes modeste pour ne pas surcharger ses serveurs. Ce tutoriel ne couvre rien derrière une connexion, les données personnelles ou de compte, l'historique des commandes, ni les médias protégés par le droit d'auteur comme la photographie de produits que vous redistribueriez. Ceux-ci sont hors de portée ici, et les atteindre va à l'encontre des conditions de Samsung.

Pour un usage commercial ou à fort volume, préférez les canaux officiels. Si vous avez besoin de données de catalogue ou de prix en masse pour la revente ou la distribution, les programmes partenaires et développeurs de Samsung sont la bonne voie, et demander une autorisation ou un flux de données est plus propre que de scraper à grande échelle. Quand le catalogue public est véritablement la seule source pour ce dont vous avez besoin, limitez le travail à ces données publiques, respectez les règles déclarées du site et consultez un professionnel juridique si votre cas d'usage est commercial ou peu clair.

Foire aux questions

Pourquoi une requête simple ne renvoie-t-elle aucun produit depuis Samsung ?

Parce que la boutique rend sa grille de produits côté client avec JavaScript. Une requête HTTP brute revient avec la coquille de la page mais les emplacements du catalogue encore vides, car les produits, prix et notes ne se remplissent qu'après l'exécution des scripts de la page dans un navigateur. Le token JS de l'API Crawling rend d'abord la page, de sorte que les cartes sont présentes quand cheerio les analyse.

Ai-je besoin du token normal ou du token JS pour Samsung ?

Utilisez le token JS. Le token normal récupère le HTML statique, ce qui laisse la grille de produits vide sur la boutique de Samsung. Le token JS rend la page dans un vrai navigateur avant de renvoyer le HTML, de sorte que le nom, le modèle, le prix, la note, le nombre d'avis, les spécifications et l'URL sont tous présents quand vous analysez.

Quelles données puis-je scraper depuis une page d'annonce Samsung ?

Les champs du catalogue public : le nom du produit, les options de modèle et de variante, le prix, la note moyenne, le nombre d'avis, les puces de spécifications clés sur chaque carte et l'URL du produit. Ce guide reste limité à ces données publiques. Il ne couvre pas les informations de compte, l'historique des commandes, ni quoi que ce soit derrière une connexion.

Mes sélecteurs cheerio renvoient des chaînes vides. Qu'est-ce qui a changé ?

Presque certainement le balisage de Samsung. Des noms de classes comme js-pfv2-product-card, pd03-product-card__product-name-text et rating__point changent sans préavis, donc des sélecteurs qui fonctionnaient le mois dernier peuvent se casser. Inspectez à nouveau une vraie annonce dans les outils de développement de votre navigateur et mettez à jour les sélecteurs. Une maintenance périodique des sélecteurs est normale pour tout scraper en production.

Puis-je scraper de nombreuses pages Samsung sans être bloqué ?

Oui, dans une certaine limite. L'API Crawling fait tourner des IP résidentielles et rend chaque page dans un vrai navigateur, donc les requêtes individuelles ressemblent à de vraies visites. Maintenez un faible débit par IP, ajoutez un court délai entre les requêtes comme indiqué dans la section mise à l'échelle, et variez vos cibles au lieu de boucler sur un seul chemin. Surveillez les codes de statut et reculez quand vous commencez à voir des challenges.

Samsung propose-t-il un moyen officiel d'obtenir des données produit ?

Pour un usage commercial ou à fort volume, les programmes partenaires et développeurs de Samsung sont le bon canal, et demander une autorisation ou un flux de données est plus propre que de scraper à grande échelle. N'utilisez le scraping que quand le catalogue public est véritablement la seule source pour les champs publics dont vous avez besoin, et limitez le travail à ces données publiques.

MA

Muhammad Atif

Développeur full stack senior · Crawlbase

Développeur full stack senior chez Crawlbase, il construit la plateforme et écrit sur l'architecture de scraping, les proxys et les pipelines de données.

IK

Ian Kalvin

Ingénieur support technique · Crawlbase

Ingénieur support technique chez Crawlbase, il écrit depuis la première ligne de ce qui casse réellement en production, sur les configurations de scraping et de proxys.