Scraping Web avec Bright Data sur Apify

Dans cet article de blog, vous apprendrez :

Ce qu’est Apify
Pourquoi l’utilisation de Scraping Browser avec Apify est un scénario gagnant-gagnant
Comment intégrer le navigateur de scraping de Bright Data dans un script Apify Python ?
Comment utiliser les mandataires de Bright Data sur Apify ?

Plongeons dans l’aventure !

Qu’est-ce qu’Apify ?

Apify est une plateforme complète de web scraping et d’extraction de données. Elle vous permet de créer et d’exécuter des outils de web scraping personnalisés, appelés ” Actors”, dansle nuage. Ces acteurs automatisent les tâches liées à la collecte, au traitement et à l’automatisation des données.

Sur Apify, vous pouvez monétiser vos scripts de scraping en les rendant publics et disponibles pour les autres utilisateurs. Que vous envisagiez d’utiliser votre Actor en privé ou de le rendre public, les solutions de scraping de Bright Data vous aideront à rendre votre scraper plus fiable et plus efficace.

Pourquoi utiliser le navigateur de scraping de Bright Data sur Apify ?

Pour apprécier la valeur du navigateur de scraping de Bright Data, vous devez comprendre ce qu’est l’outil et ce qu’il offre.

La principale limite des outils d’automatisation des navigateurs n’est pas leur API, mais plutôt les navigateurs qu’ils contrôlent. Scraping Browser est un navigateur web de nouvelle génération spécialement conçu pour le web scraping. Il présente notamment les caractéristiques suivantes :

Empreintes TLS fiables pour éviter la détection
Évolutivité illimitée pour l’extraction de données à grande échelle
Rotation IP intégrée alimentée par un réseau de 150 millions de proxy IP
Réessais automatiques pour traiter les demandes qui n’aboutissent pas
Capacités de résolution des CAPTCHA

Scraping Browser est compatible avec tous les principaux cadres d’automatisation de navigateur, y compris Playwright, Puppeteer et Selenium. Vous n’avez donc pas besoin d’apprendre une nouvelle API ou d’installer des dépendances tierces. Vous pouvez simplement l’intégrer directement dans votre script d’automatisation de scraping existant.

Désormais, l’utilisation de Scraping Browser avec Apify apporte encore plus d’avantages, ce qui se traduit par les bénéfices suivants :

Réduction des coûts liés à l’informatique en nuage: Les navigateurs consomment des ressources importantes, ce qui entraîne une utilisation accrue de l’unité centrale et de la mémoire vive. Scraping Browser, hébergé sur le cloud avec une garantie d’évolutivité illimitée, réduit les coûts liés au cloud pendant l’exécution des acteurs sur Apify. Étant donné qu’Apify facture l’utilisation du serveur, même en tenant compte des frais de Scraping Browser, cette configuration peut permettre de réaliser des économies.
Outil tout-en-un de contournement des robots: Scraping Browser s’attaque aux interdictions d’IP, aux défis CAPTCHA, aux problèmes d’empreintes digitales du navigateur et à d’autres barrières anti-scraping. Cela rend votre processus de scraping plus efficace et moins susceptible d’être perturbé.
Intégration de proxy intégrée: Scraping Browser intègre la gestion des proxys, de sorte que vous n’avez plus à vous soucier de la maintenance et de la rotation manuelle des proxys.
Avantages d’Apify: L’utilisation de Scraping Browser sur un acteur Apify (au lieu d’un script générique) offre des avantages supplémentaires, tels que
```
:Polylang placeholder do not modify
```

L’intégration Bright Data + Apify simplifie non seulement votre flux de travail de scraping, mais améliore également la fiabilité. Elle réduit également le temps et les efforts nécessaires à la mise en ligne de votre bot de scraping web.

Comment intégrer le navigateur de scraping de Bright Data sur Apify : Guide étape par étape

Le site cible de cette section est Amazon, une plateforme riche en informations mais connue pour ses mesures anti-bots strictes. Sans les outils adéquats, vous risquez de rencontrer le fameux CAPTCHA d’Amazon, qui bloquera vos tentatives de scraping :

Dans cette section, nous allons construire un acteur de scraping qui exploite le navigateur de scraping de Bright Data pour extraire des données d’une page de recherche générique de produits Amazon :

La page de recherche du produit Amazon cible

Note: L’acteur sera écrit en Python, mais n’oubliez pas qu’Apify prend également en charge JavaScript.

Suivez les étapes ci-dessous pour apprendre à intégrer les outils de scraping de Bright Data à Apify !

Conditions préalables

Pour suivre ce tutoriel, vous devez remplir les conditions préalables suivantes :

Python 3.8+ installé localement: Pour développer et construire le script Actor local.
Node.js installé localement: Pour l’installation de l’Apify CLI.
Un compte Apify: Pour déployer l’acteur local sur la plateforme Apify.
Un compte Bright Data: Pour accéder au Scraping Browser.

Étape 1 : Configuration du projet

La manière la plus simple de mettre en place un nouveau projet Apify Actor est d’utiliser le CLI Apify. Tout d’abord, installez-le globalement via Node.js avec la commande suivante :

npm install -g apify-cli

Ensuite, créez un nouveau projet Apify en exécutant :

npx apify-cli create

Vous serez invité à répondre à quelques questions. Répondez comme suit :

✔ Name of your new Actor: amazon-scraper
✔ Choose the programming language of your new Actor: Python
✔ Choose a template for your new Actor. Detailed information about the template will be shown in the next step.
Playwright + Chrome

De cette façon, la CLI Apify créera un nouvel acteur Python dans le dossier amazon-scraper en utilisant le modèle “Playwright + Chrome”. Si vous n’êtes pas familier avec ces outils, lisez notre guide sur le web scraping avec Playwright.

Remarque: un modèle Selenium ou Puppeteer fonctionnerait également, car le navigateur de capture de Bright Data s’intègre à n’importe quel outil d’automatisation de navigateur.

Votre projet Apify Actor aura la structure suivante :

amazon-scraper
│── .dockerignore
│── .gitignore
│── README.md
│── requirements.txt
│
├── .venv/
│   └── ...
│
├── .actor/
│   │── actor.json
│   │── Dockerfile
│   └── input_schema.json
│
├── src/
│   │── main.py
│   │── __init__.py
│   │── __main__.py
│   └── py.typed
│
└── storage/
    └── ...

Chargez le dossier amazon-scraper dans votre IDE Python préféré, tel que Visual Studio Code avec l’extension Python ou PyCharm Community Edition.

N’oubliez pas que pour exécuter l’acteur localement, les navigateurs Playwright doivent être installés. Pour ce faire, activez d’abord le dossier de l’environnement virtuel (.venv) dans le répertoire de votre projet. Sous Windows, exécutez :

.venv/Scripts/activate

De manière équivalente, sous Linux/macOS, lancez :

source .venv/bin/activate

Ensuite, installez les dépendances Playwright requises en exécutant :

playwright install --with-deps

C’est formidable ! Vous pouvez maintenant exécuter votre Actor localement avec :

apify run

Votre projet Apify est maintenant entièrement configuré et prêt à être intégré au navigateur de scraping de Bright Data !

Étape 2 : Connexion à la page cible

Si vous regardez l’URL d’une page de résultats de recherche Amazon, vous remarquerez qu’elle suit ce format :

https://www.amazon.com/search/s?k=<keyword>

Par exemple :

L’URL cible de votre script doit utiliser ce format, où peut être défini dynamiquement à l’aide d’un argument d’entrée Apify. Les paramètres d’entrée qu’un acteur accepte sont définis dans le fichier input_schema.json, situé dans le répertoire .actor.

La définition de l’argument keyword rend le script personnalisable, permettant aux utilisateurs de spécifier le terme de recherche qu’ils préfèrent. Pour définir ce paramètre, remplacez le contenu de input_schema.json par le suivant :

{
    "title": "Amazon Scraper",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "keyword": {
            "title": "Search keyword",
            "type": "string",
            "description": "The keyword used to search products on Amazon",
            "editor": "textfield"
        }
    },
    "required": ["keyword"]
}

Cette configuration définit un paramètre obligatoire de type chaîne de caractères.

Pour définir l’argument mot-clé lors de l’exécution locale de l’acteur, modifiez le fichier INPUT.json dans storage/key_value_stores/default comme suit :

{
    "keyword": "laptop"
}

Ainsi, l’acteur lira l’argument d’entrée du mot-clé, en utilisant "ordinateur portable" comme terme de recherche.

Une fois que l’acteur est déployé sur la plateforme Apify, vous verrez un champ de saisie dans lequel vous pourrez personnaliser ce paramètre avant d’exécuter l’acteur :

Le champ de texte du mot-clé configuré dans la console Apify

Gardez à l’esprit que le fichier d’entrée d’un Acteur Apify est main.py, situé dans le dossier src. Ouvrez ce fichier et modifiez-le en :

Lire le mot-clé paramètre à partir des arguments d’entrée
Construire l’URL cible pour la page de recherche Amazon
Utilisez Playwright pour naviguer vers cette page

À la fin de cette étape, votre fichier main.py devrait contenir la logique Python ci-dessous :

from apify import Actor
from playwright.async_api import async_playwright


async def main() -> None:
    # Enter the context of the Actor
    async with Actor:
        # Retrieve the Actor input, and use default values if not provided
        actor_input = await Actor.get_input() or {}
        # Reading the "keyword" argument from the input data, assigning it the
        # value "laptop" as a default value
        keyword = actor_input.get("keyword")

        # Building the target url
        target_url = f"https://www.amazon.com/search/s?k={keyword}"

        # Launch Playwright and open a new browser context
        async with async_playwright() as playwright:
            # Configure the browser to launch in headless mode as per Actor configuration
            browser = await playwright.chromium.launch(
                headless=Actor.config.headless,
                args=["--disable-gpu"],
            )
            context = await browser.new_context()

            try:
                # Open a new page in the browser context and navigate to the URL
                page = await context.new_page()
                await page.goto(target_url)

                # Scraping logic...

            except Exception:
                Actor.log.exception(f"Cannot extract data from {target_url}")

            finally:
                await page.close()

Le code ci-dessus :

Initialise un acteur Apify pour gérer le cycle de vie du script
Récupère les arguments d’entrée en utilisant Actor.get_input()
Extrait le mot-clé argument des données d’entrée
Construit l’URL cible à l’aide d’une chaîne de caractères Python.
Lance Playwright et démarre un navigateur Chromium sans tête avec le GPU désactivé.
Crée un nouveau contexte de navigation, ouvre une page et navigue vers l’URL cible à l’aide de page.goto()
Enregistre les erreurs avec Actor.log.exception()
Veille à ce que la page Playwright soit fermée après l’exécution.

C’est parfait ! Votre Apify Actor est prêt à exploiter le navigateur de scraping de Bright Data pour un scraping web efficace.

Étape 3 : Intégrer le navigateur de scraping de Bright Data

Utilisez maintenant l’API Playwright pour réaliser une capture d’écran après vous être connecté à la page cible :

await page.screenshot(path="screenshot.png")

Exécutez votre Actor localement, et il générera un fichier screenshot.png dans le dossier du projet. Ouvrez-le, et vous verrez probablement quelque chose comme ceci :

De même, vous pouvez obtenir la page d’erreur Amazon suivante :

Comme vous pouvez le constater, votre robot de scraping a été bloqué par les mesures anti-bots d’Amazon. Ce n’est là qu’un des nombreux problèmes que vous pouvez rencontrer lorsque vous scrappez Amazon ou d’autres sites web populaires.

Oubliez ces défis en utilisant le navigateur de scraping de Bright Data, unesolution de scraping basée sur le cloud qui offre une évolutivité illimitée, une rotation automatique des adresses IP, la résolution des CAPTCHA et le contournement de l’anti-scraping.

Pour commencer, si vous ne l’avez pas encore fait, créez un compte Bright Data. Ensuite, connectez-vous à la plateforme. Dans la section “Tableau de bord de l’utilisateur”, cliquez sur le bouton “Obtenir des produits proxy” :

Appuyer sur le bouton "Obtenir des produits proxy".

Dans le tableau “My Zones” de la page “Proxies & Scraping Infrastructure”, sélectionnez la ligne “scraping_browser” :

Activer le produit en basculant l’interrupteur marche/arrêt :

Dans l’onglet “Configuration”, vérifiez que les options “Domaines Premium” et “CAPTCHA Solver” sont activées pour une efficacité maximale :

Activation des options "Domaines Premium" et "CAPTCHA Solver".

Dans l’onglet “Overview”, copiez la chaîne de connexion du navigateur Playwright Scraping Browser :

Copier la chaîne de connexion du navigateur Puppeteer / Playwright Scraping dans le presse-papiers

Ajoutez la chaîne de connexion à votre fichier main.py en tant que constante :

SBR_WS_CDP = "<YOUR_PLAYWRIGHT_SCRAPING_BROWSER_CONNECTION_STRING>"

Remplacez par la chaîne de connexion que vous avez copiée précédemment.

Remarque: si vous envisagez de rendre votre acteur public sur Apify, vous devez définir SBR_WS_CDP comme un argument d’entrée de l’acteur Apify. De cette façon, les utilisateurs qui adoptent votre Acteur pourront intégrer leurs propres chaînes de connexion au Scraping Browser.

Maintenant, mettez à jour la définition du navigateur dans main.py pour utiliser Scraping Browser avec Playwright :

browser = await playwright.chromium.connect_over_cdp(SBR_WS_CDP, timeout=120000)

Notez que le délai de connexion doit être fixé à une valeur plus élevée que d’habitude, car la rotation des IP à travers les proxys et la résolution des CAPTCHA peuvent prendre un certain temps.

C’est fait ! Vous avez intégré avec succès Scraping Browser dans Playwright au sein d’Apify Actor.

Étape 4 : Préparer la récupération de toutes les listes de produits

Pour extraire des listes de produits d’Amazon, vous devez d’abord inspecter la page afin de comprendre sa structure HTML. Pour ce faire, cliquez avec le bouton droit de la souris sur l’un des éléments de produit de la page et sélectionnez l’option “Inspecter”. La section DevTools suivante s’affiche :

Inspection de l'élément de la liste des produits

Ici, vous pouvez voir que chaque élément de la liste de produits peut être sélectionné à l’aide de ce sélecteur CSS :

[data-component-type=\"s-search-result\"]

Le ciblage des attributs data-* personnalisés est idéal car ces attributs sont généralement utilisés pour les tests ou la surveillance. Ils ont donc tendance à rester cohérents dans le temps.

Maintenant, utilisez un localisateur Playwright pour récupérer tous les éléments du produit sur la page :

product_elements = page.locator("[data-component-type=\"s-search-result\"]")

Ensuite, il faut itérer sur les éléments du produit et se préparer à en extraire des données :

for product_element in await product_elements.all():
    # Data extraction logic...

Incroyable ! Il est temps de mettre en œuvre la logique d’extraction des données d’Amazon.

Étape 5 : Mise en œuvre de la logique de scraping

Commencez par inspecter un élément individuel de la liste de produits :

Dans cette section, vous pouvez récupérer l’image du produit à partir de l’attribut src de l’élément .s-image:

image_element = product_element.locator(".s-image").nth(0)
image = await image_element.get_attribute("src")

Notez que nth(0) est nécessaire pour obtenir le premier élément HTML correspondant au localisateur.

Examinez ensuite le titre du produit :

Vous pouvez recueillir l’URL et le titre du produit dans les champs et

à l’intérieur de l’élément [data-cy="title-recipe"], respectivement :

title_header_element = product_element.locator("[data-cy=\"title-recipe\"]").nth(0)

link_element = title_header_element.locator("a").nth(0)
url = None if url_text == "javascript:void(0)" else "https://amazon.com" + url_text

title_element = title_header_element.locator("h2").nth(0)
title = await title_element.get_attribute("aria-label")

Notez la logique utilisée pour ignorer les URL “javascript:void(0)” (qui apparaissent sur les produits publicitaires spéciaux) et le traitement permettant de convertir les URL des produits en URL absolues.

Ensuite, consultez la section des critiques :

À partir de [data-cy="reviews-block"], vous pouvez obtenir l’évaluation de l’avis à partir de l’étiquette aria de l’élément de l’élément [data-cy=”reviews-block”] :

rating_element =  product_element.locator("[data-cy=\"reviews-block\"] a").nth(0)
rating_text = await rating_element.get_attribute("aria-label")
rating_match = re.search(r"(\d+(\.\d+)?) out of 5 stars", rating_text)
if rating_match:
    rating = rating_match.group(1)
else:
    rating = None

Comme le texte de l’évaluation dans aria-label est au format “X sur 5 étoiles”, vous pouvez extraire la valeur de l’évaluation X à l’aide d’une simple expression rationnelle. Voir comment utiliser les regex pour le web scraping.

N’oubliez pas d’importer re de la bibliothèque standard de Python :

import re

Inspectez maintenant l’élément “review count” :

Extraire le nombre de commentaires de l’élément dans [data-component-type="s-client-side-analytics"]:

review_count_element = product_element.locator("[data-component-type=\"s-client-side-analytics\"] a").nth(0)
review_count_text = await review_count_element.text_content()
review_count = int(review_count_text.replace(",", ""))

Remarquez la logique simple qui permet de convertir une chaîne de caractères comme “2 539” en une valeur numérique en Python.

Enfin, inspectez le nœud de prix du produit :

Collecter le prix du produit à partir de l’élément .a-offscreen à l’intérieur de [data-cy="price-recipe"] :

price_element_locator = product_element.locator("[data-cy=\"price-recipe\"] .a-offscreen")
# If the price element is on the product element
if await price_element_locator.count() > 0:
    price = await price_element_locator.nth(0).text_content()
else:
    price = None

Étant donné que tous les produits n’ont pas d’élément de prix, vous devez gérer ce scénario en vérifiant le nombre d’éléments de prix avant d’essayer d’en extraire la valeur.

Pour que le script fonctionne, mettez à jour l’importation Playwright avec :

from playwright.async_api import async_playwright, TimeoutError

Superbe ! La logique de récupération des données des produits Amazon est terminée.

Notez que l’objectif de cet article n’est pas de plonger dans la logique de scraping d’Amazon. Pour plus d’informations, suivez notre guide sur la manière de récupérer des données de produits Amazon en Python.

Étape 6 : Collecte des données récupérées

La dernière instruction de la boucle for consiste à remplir un objet produit avec les données extraites :

product = {
    "image": image,
    "url": url,
    "title": title,
    "rating": rating,
    "review_count": review_count,
    "price": price
}

Ensuite, il est transféré dans l’ensemble de données Apify:

await Actor.push_data(product)

push_data() garantit que les données scannées sont enregistrées sur Apify, ce qui vous permet d’y accéder via l’API ou de les exporter dans l’un des nombreux formats pris en charge (par exemple, CSV, JSON, Excel, JSONL, etc.).

Étape n° 7 : Assembler le tout

C’est ce que doit contenir le fichier main.py final d’Apify + Bright Data Actor :

from apify import Actor
from playwright.async_api import async_playwright, TimeoutError
import re

async def main() -> None:
    # Enter the context of the Actor
    async with Actor:
        # Retrieve the Actor input, and use default values if not provided
        actor_input = await Actor.get_input() or {}
        # Reading the "keyword" argument from the input data, assigning it the
        # value "laptop" as a default value
        keyword = actor_input.get("keyword")

        # Building the target url
        target_url = f"https://www.amazon.com/search/s?k={keyword}"

        # Launch Playwright and open a new browser context
        async with async_playwright() as playwright:
            # Your Bright Data Scraping API connection string
            SBR_WS_CDP = "wss://brd-customer-username-zone-scraping_browser:[email protected]:9222"

            # Configure Playwright to connect to Scraping Browser and open a new context
            browser = await playwright.chromium.connect_over_cdp(SBR_WS_CDP, timeout=120000)
            context = await browser.new_context()

            try:
                # Open a new page in the browser context and navigate to the URL
                page = await context.new_page()
                await page.goto(target_url)

                # Use a locator to select all product elements
                product_elements = page.locator("[data-component-type=\"s-search-result\"]")

                # Iterate over all product elements and scrape data from them
                for product_element in await product_elements.all():
                    # Product scraping logic
                    image_element = product_element.locator(".s-image").nth(0)
                    image = await image_element.get_attribute("src")

                    title_header_element = product_element.locator("[data-cy=\"title-recipe\"]").nth(0)

                    link_element = title_header_element.locator("a").nth(0)
                    url_text = await link_element.get_attribute("href")
                    url = None if url_text == "javascript:void(0)" else "https://amazon.com" + url_text

                    title_element = title_header_element.locator("h2").nth(0)
                    title = await title_element.get_attribute("aria-label")

                    rating_element =  product_element.locator("[data-cy=\"reviews-block\"] a").nth(0)
                    rating_text = await rating_element.get_attribute("aria-label")
                    rating_match = re.search(r"(\d+(\.\d+)?) out of 5 stars", rating_text)
                    if rating_match:
                        rating = rating_match.group(1)
                    else:
                        rating = None

                    review_count_element = product_element.locator("[data-component-type=\"s-client-side-analytics\"] a").nth(0)
                    review_count_text = await review_count_element.text_content()
                    review_count = int(review_count_text.replace(",", ""))

                    price_element_locator = product_element.locator("[data-cy=\"price-recipe\"] .a-offscreen")
                    # If the price element is on the product element
                    if await price_element_locator.count() > 0:
                        price = await price_element_locator.nth(0).text_content()
                    else:
                        price = None

                    # Populate a new dictionary with the scraped data
                    product = {
                        "image": image,
                        "url": url,
                        "title": title,
                        "rating": rating,
                        "review_count": review_count,
                        "price": price
                    }
                    # Add it to the Actor dataset
                    await Actor.push_data(product)
            except Exception:
                Actor.log.exception(f"Cannot extract data from {target_url}")

            finally:
                await page.close()

Comme vous pouvez le constater, l’intégration du navigateur de scraping de Bright Data au modèle “Playwright + Chrome” d’Apify est simple et ne nécessite que quelques lignes de code.

Étape 8 : Déploiement sur Apify et exécution de l’acteur

Pour déployer votre Actor local sur Apify, exécutez la commande suivante dans le dossier de votre projet :

apify push

Si vous ne vous êtes pas encore connecté, vous serez invité à vous authentifier via le CLI Apify.

Une fois le déploiement terminé, la question suivante vous sera posée :

✔ Do you want to open the Actor detail in your browser?

Répondez par “Y” ou “oui” pour être redirigé vers la page Acteur dans votre console Apify :

Si vous préférez, vous pouvez accéder manuellement à la même page :

Connexion à Apify dans votre navigateur
Naviguer vers la console
Visite de la page “Acteur

Cliquez sur le bouton “Start Actor” pour lancer votre Amazon Scraper Actor. Comme prévu, il vous sera demandé de fournir un mot-clé. Essayez quelque chose comme “chaise de jeu” :

Remplir l'élément de saisie du champ de texte du mot-clé

Ensuite, cliquez sur “Save & Start” pour lancer l’Acteur et récupérer les listes de produits “gaming chair” sur Amazon.

Une fois le scraping terminé, vous verrez les données récupérées dans la section Output :

Les données récupérées sous forme de tableau

Pour exporter les données, allez dans l’onglet “Stockage”, sélectionnez l’option “CSV” et appuyez sur le bouton “Télécharger” :

Le fichier CSV téléchargé contiendra les données suivantes :

Et voilà ! Le navigateur de scraping de Bright Data + l’intégration d’Apify fonctionnent comme un charme. Plus de CAPTCHAs ou de blocages lors du scraping d’Amazon ou de tout autre site.

[Extra] Intégration de Bright Data Proxy sur Apify

L’utilisation d’un produit de scraping comme Scraping Browser ou Web Unlocker directement sur Apify est utile et simple.

Dans le même temps, supposons que vous ayez déjà un acteur sur Apify et que vous ayez simplement besoin de l’améliorer avec des proxies (par exemple, pour éviter les interdictions d’IP). N’oubliez pas que vous pouvez intégrer les proxies de Bright Data directement dans votre acteur Apify, comme décrit dans notre documentation ou notre guide d’intégration.

Conclusion

Dans ce tutoriel, vous avez appris à construire un acteur Apify qui s’intègre à Scraping Browser dans Playwright pour collecter de manière programmatique des données d’Amazon. Nous sommes partis de zéro, en parcourant toutes les étapes de la construction d’un script de scraping local, puis de son déploiement sur Apify.

Vous comprenez maintenant les avantages de l’utilisation d’un outil de scraping professionnel comme Scraping Browser pour votre cloud scraping sur Apify. En suivant des procédures identiques ou similaires, Apify prend en charge tous les autres produits de Bright Data :

Services Proxy: 4 types de proxy différents pour contourner les restrictions de localisation, y compris plus de 150 millions d’adresses IP résidentielles.
API de grattage Web: Points d’extrémité dédiés à l’extraction de données web fraîches et structurées à partir de plus de 100 domaines populaires.
API SERP: API pour gérer toutes les opérations de déverrouillage en cours pour les SERP et extraire une page.

Inscrivez-vous dès maintenant à Bright Data et testez gratuitement nos services proxy interopérables et nos produits de scraping !

Essai gratuit

S’inscrire avec Google

Aucune carte de crédit requise

Récupération de données sur le Web à l’aide du navigateur de récupération de Bright Data sur Apify