Le Web Scraping avec Pydoll en 2025 : Guide étape par étape

.quote

Maintenant, utilisez Pydoll pour attendre que ces éléments apparaissent avant de continuer :

await page.wait_element(By.CSS_SELECTOR, ".quote", timeout=3)

N’oubliez pas d’importer By :

from pydoll.constants import By

Exécutez à nouveau le script, et vous verrez cette fois que Pydoll attend que les éléments de la citation se chargent avant de fermer le navigateur. C’est du bon travail !

Étape 5 : Préparer le scraping Web

N’oubliez pas que la page cible contient plus d’une citation. Puisque vous voulez toutes les récupérer, vous avez besoin d’une structure de données pour les contenir. Un simple tableau fonctionne parfaitement, il faut donc en initialiser un :

quotes = []

Pour trouver des éléments de la page, Pydoll propose deux méthodes pratiques :

• find_element(): Recherche le premier élément correspondant
• find_elements(): Recherche tous les éléments correspondants

Tout comme wait_element(), ces méthodes acceptent un sélecteur utilisant l’objet By.

Sélectionnez donc tous les éléments de citation de la page avec :

quote_elements = await page.find_elements(By.CSS_SELECTOR, ".quote")

Ensuite, passez en revue les éléments et préparez-vous à appliquer votre logique d’extraction :

for quote_element in quote_elements:
  # Scraping logic...

Formidable ! Il est temps de passer à la logique d’extraction des données.

Étape 6 : Mise en œuvre de la logique d’analyse des données

Commencez par inspecter un seul élément de la citation :

Comme vous pouvez le constater dans le code HTML ci-dessus, un élément de citation unique contient :

• Le texte cité dans un nœud .text
• L’auteur dans l’élément .author
• Une liste de balises dans les éléments .tag

Mettre en œuvre la logique de scraping pour sélectionner ces éléments et en extraire les données qui nous intéressent :

# Extract the quote text (and remove curly quotes)
text_element = await quote_element.find_element(By.CSS_SELECTOR, ".text")
text = (await text_element.get_element_text()).replace("“", "").replace("”", "")

# Extract the author name
author_element = await quote_element.find_element(By.CSS_SELECTOR, ".author")
author = await author_element.get_element_text()

# Extract all associated tags
tag_elements = await quote_element.find_elements(By.CSS_SELECTOR, ".tag")
tags = [await tag_element.get_element_text() for tag_element in tag_elements]

Note: La méthode replace() supprime les guillemets doubles inutiles du texte extrait.

Utilisez maintenant les données récupérées pour créer un nouvel objet dictionnaire et ajoutez-le au tableau des citations:

# Populate a new quote with the scraped data
quote = {
    "text": text,
    "author": author,
    "tags": tags
}
# Append the extracted quote to the list
quotes.append(quote)

Voilà qui est fait ! Il ne reste plus qu’à exporter les données scannées au format CSV.

Étape 7 : Exporter au format CSV

Actuellement, les données extraites sont stockées dans une liste Python. Facilitez le partage et l’exploration avec d’autres personnes en les exportant dans un format lisible par l’homme, tel que le format CSV.

Utilisez Python pour créer un nouveau fichier appelé quotes.csv et le remplir avec les données extraites :

with open("quotes.csv", "w", newline="", encoding="utf-8") as csvfile:
            # Add the header
            fieldnames = ["text", "author", "tags"]
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

            # Populate the output file with the scraped data
            writer.writeheader()
            for quote in quotes:
                writer.writerow(quote)

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

import csv

Mission accomplie ! Votre gratte-pydoll est prêt pour l’exécution.

Étape n° 8 : Assembler le tout

Le fichier scraper.py doit maintenant contenir :

import asyncio
from pydoll.browser.chrome import Chrome
from pydoll.constants import By
import csv

async def main():
    async with Chrome() as browser:
        # Launch the Chrome browser and open a new page
        await browser.start()
        page = await browser.get_page()

        # Navigate to the target page
        await page.go_to("https://quotes.toscrape.com/js-delayed/?delay=2000")

        # Wait up to 3 seconds for the quote elements to appear
        await page.wait_element(By.CSS_SELECTOR, ".quote", timeout=3)

        # Where to store the scraped data
        quotes = []

        # Select all quote elements
        quote_elements = await page.find_elements(By.CSS_SELECTOR, ".quote")

        # Iterate over them and scrape data from them
        for quote_element in quote_elements:
            # Extract the quote text (and remove curly quotes)
            text_element = await quote_element.find_element(By.CSS_SELECTOR, ".text")
            text = (await text_element.get_element_text()).replace("“", "").replace("”", "")

            # Extract the author
            author_element = await quote_element.find_element(By.CSS_SELECTOR, ".author")
            author = await author_element.get_element_text()

            # Extract all tags
            tag_elements = await quote_element.find_elements(By.CSS_SELECTOR, ".tag")
            tags = [await tag_element.get_element_text() for tag_element in tag_elements]

            # Populate a new quote with the scraped data
            quote = {
                "text": text,
                "author": author,
                "tags": tags
            }
            # Append the extracted quote to the list
            quotes.append(quote)

    # Export the scraped data to CSV
    with open("quotes.csv", "w", newline="", encoding="utf-8") as csvfile:
                # Add the header
                fieldnames = ["text", "author", "tags"]
                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

                # Populate the output file with the scraped data
                writer.writeheader()
                for quote in quotes:
                    writer.writerow(quote)

# Execute the async scraping function
asyncio.run(main())

Ouah ! En moins de 60 lignes de code, vous pouvez construire un robot d’exploration du web avec Pydoll.

Testez le script ci-dessus en l’exécutant :

python scraper.py

Une fois l’exécution terminée, un fichier quotes.csv apparaîtra dans le dossier de votre projet. Ouvrez-le, et vous verrez les données scrappées proprement organisées :

Et voilà ! Votre script de scraping web Pydoll fonctionne comme prévu.

Contourner Cloudflare avec Pydoll

Lorsque vous interagissez avec un site dans un outil d’automatisation de navigateur, l’un des plus grands défis auxquels vous serez confronté est celui des pare-feu d’application web (WAF). Pensez à des solutions comme Cloudflare, qui sont généralement dotées de protections anti-bots avancées.

Lorsque l’on soupçonne que vos demandes proviennent d’un navigateur automatisé, ces systèmes affichent généralement un CAPTCHA. Dans certains cas, ils le présentent à tous les utilisateurs lors de leur première visite sur le site.

Contourner les CAPTCHAs en Python n’est pas une mince affaire. Cependant, il existe des moyens de faire croire à Cloudflare que vous êtes un utilisateur réel, de sorte qu’il n’affiche pas de CAPTCHA en premier lieu. C’est là que Pydoll entre en jeu, en fournissant une API dédiée à cette fin.

Pour démontrer son fonctionnement, nous utiliserons la page de test “Antibot Challenge” du site ScrapingCourse :

Comme vous pouvez le voir, la page exécute toujours le défi JavaScript de Cloudflare. Une fois contournée, elle affiche un échantillon de contenu pour confirmer que la protection anti-bot a été déjouée.

Pydoll propose deux approches pour gérer Cloudflare :

1. Approche du gestionnaire de contexte: Traite le défi anti-bot de manière synchrone, en interrompant l’exécution du script jusqu’à ce que le défi soit résolu.
2. Approche de traitement en arrière-plan: Traite l’anti-bot de manière asynchrone en arrière-plan.

Nous allons couvrir les deux méthodes. Cependant, comme le mentionne la documentation officielle, gardez à l’esprit que le contournement de Cloudflare ne fonctionne pas toujours. Cela est dû à des problèmes tels que la réputation de l’IP ou l’historique de navigation.

Pour des techniques plus avancées, lisez notre tutoriel complet sur le scraping de sites protégés par Cloudflare.

Approche du gestionnaire de contexte

Pour laisser Pydoll gérer automatiquement le défi anti-bot de Cloudflare pour vous, utilisez la méthode expect_and_bypass_cloudflare_captcha() comme ceci :

import asyncio
from pydoll.browser.chrome import Chrome
from pydoll.constants import By

async def main():
    async with Chrome() as browser:
        # Launch the Chrome browser and open a new page
        await browser.start()
        page = await browser.get_page()

        # Wait for the Cloudflare challenge to be executed
        async with page.expect_and_bypass_cloudflare_captcha():
            # Connect to the Cloudflare-protected page:
            await page.go_to("https://www.scrapingcourse.com/antibot-challenge")
            print("Waiting for Cloudflare anti-bot to be handled...")

        # This code runs only after the anti-bot is successfully bypassed
        print("Cloudflare anti-bot bypassed! Continuing with automation...")

        # Print the text message on the success page
        await page.wait_element(By.CSS_SELECTOR, "#challenge-title", timeout=3)
        success_element = await page.find_element(By.CSS_SELECTOR, "#challenge-title")
        success_text = await success_element.get_element_text()
        print(success_text)

asyncio.run(main())

Lorsque vous exécutez ce script, la fenêtre de Chrome contourne automatiquement le défi et charge la page cible.

Le résultat sera le suivant :

Waiting for Cloudflare anti-bot to be handled...
Cloudflare anti-bot bypassed! Continuing with automation...
You bypassed the Antibot challenge! :D

Approche du traitement en arrière-plan

Si vous préférez ne pas bloquer l’exécution du script pendant que Pydoll gère le défi Cloudflare, vous pouvez utiliser les méthodes enable_auto_solve_cloudflare_captcha() et disable_auto_solve_cloudflare_captcha() comme suit :

import asyncio
from pydoll.browser import Chrome
from pydoll.constants import By

async def main():
    async with Chrome() as browser:
        # Launch the Chrome browser and open a new page
        await browser.start()
        page = await browser.get_page()

        # Enable automatic captcha solving before navigating
        await page.enable_auto_solve_cloudflare_captcha()

        # Connect to the Cloudflare-protected page:
        await page.go_to("https://www.scrapingcourse.com/antibot-challenge")
        print("Page loaded, Cloudflare anti-bot will be handled in the background...")

        # Disable anti-bot auto-solving when no longer needed
        await page.disable_auto_solve_cloudflare_captcha()

        # Print the text message on the success page
        await page.wait_element(By.CSS_SELECTOR, "#challenge-title", timeout=3)
        success_element = await page.find_element(By.CSS_SELECTOR, "#challenge-title")
        success_text = await success_element.get_element_text()
        print(success_text)

asyncio.run(main())

Cette approche permet à votre scraper d’effectuer d’autres opérations pendant que Pydoll résout le problème de l’anti-bot de Cloudflare en arrière-plan.

Cette fois, le résultat sera :

Page loaded, Cloudflare anti-bot will be handled in the background...
You bypassed the Antibot challenge! :D

Limites de cette approche du Web Scraping

Avec Pydoll – ou tout autre outil de scraping – sivous envoyez trop de requêtes, il y a de fortes chances que vous soyez bloqué par le serveur cible. Cela est dû au fait que la plupart des sites web mettent en place une limitation de débit pour empêcher les robots (comme votre script de scraping) de submerger leurs serveurs de requêtes.

Il s’agit d’une technique courante de lutte contre le scraping et le DDoS. Après tout, personne ne souhaite que son site soit inondé par un trafic automatisé.

Même si vous suivez les meilleures pratiques, comme le respect du fichier robots.txt, le fait d’effectuer de nombreuses requêtes à partir de la même adresse IP peut toujours éveiller les soupçons. Par conséquent, vous risquez toujours de rencontrer des erreurs 403 Forbidden (Interdit) ou 429 Too Many Requests (Trop de demandes).

La meilleure façon d’éviter cela est de faire tourner votre adresse IP à l’aide d’un proxy web.

Si vous n’êtes pas familier avec cela, un proxy web agit comme un intermédiaire entre votre scraper et le site web cible. Il transmet vos demandes et renvoie les réponses, ce qui donne l’impression au site cible que le trafic provient du proxy et non de votre machine.

Cette technique permet non seulement de dissimuler votre véritable adresse IP, mais aussi de contourner les restrictions géographiques et de nombreux autres cas d’utilisation.

Il existe aujourd’hui plusieurs types de proxies. Pour éviter d’être bloqué, vous avez besoin d’un fournisseur de haute qualité offrant des proxies rotatifs authentiques comme Bright Data.

Dans la section suivante, vous verrez comment intégrer les proxys rotatifs de Bright Data à Pydoll pour récupérer des pages Web plus efficacement, en particulier à grande échelle.

Intégration de Pydoll avec les proxy rotatifs de Bright Data

Bright Data contrôle l’un des plus grands réseaux de serveurs mandataires au monde, auquel font confiance les entreprises du classement Fortune 500 et plus de 20 000 clients. Son réseau de serveurs mandataires comprend

• Proxies de centres de données – Plus de 770 000 IP de centres de données.
• Proxies résidentiels – Plus de 150 000 000 IP résidentielles dans plus de 195 pays.
• Proxies ISP – Plus de 700 000 IP ISP.
• Proxies mobiles – Plus de 7 000 000 d’IP mobiles.

Suivez les étapes ci-dessous et apprenez à utiliser les proxys résidentiels de Bright Data avec Pydoll.

Si vous n’avez pas encore de compte, inscrivez-vous à Bright Data. Sinon, connectez-vous pour accéder à votre tableau de bord :

Dans le tableau de bord, cliquez sur le bouton “Obtenir des produits proxy” :

Vous serez redirigé vers la page “Proxies & Scraping Infrastructure” :

Dans le tableau, recherchez la ligne “Résidentiel” et cliquez dessus :

Vous arrivez sur la page de configuration du proxy résidentiel :

Si c’est votre première fois, suivez l’assistant d’installation pour configurer le proxy en fonction de vos besoins. Pour obtenir de l’aide, contactez le service d’assistance 24/7.

Allez dans l’onglet “Aperçu” et localisez l’hôte, le port, le nom d’utilisateur et le mot de passe de votre proxy :

Utilisez ces détails pour construire votre URL de proxy :

proxy_url = "<brightdata_proxy_username>:<brightdata_proxy_password>@<brightdata_proxy_host>:<brightdata_proxy_port>";

Remplacez les espaces réservés (, , , ) par les informations d’identification de votre proxy.

Veillez à activer le produit proxy en faisant passer l’interrupteur de “Off” à “On” :

Maintenant que votre proxy est prêt, voici comment l’intégrer dans Pydoll en utilisant ses capacités de configuration de proxy intégrées:

import asyncio
from pydoll.browser.chrome import Chrome
from pydoll.browser.options import Options
from pydoll.constants import By
import traceback

async def main():
    # Create browser options
    options = Options()

    # The URL of your Bright Data proxy
    proxy_url = "<brightdata_proxy_username>:<brightdata_proxy_password>@<brightdata_proxy_host>:<brightdata_proxy_port>" # Replace it with your proxy URL

    # Configure the proxy integration option
    options.add_argument(f"--proxy-server={proxy_url}")

    # To avoid potential SSL errors
    options.add_argument("--ignore-certificate-errors")

    # Start browser with proxy configuration
    async with Chrome(options=options) as browser:
        await browser.start()
        page = await browser.get_page()

        # Visit a special page that returns the IP of the caller
        await page.go_to("https://httpbin.io/ip")

        # Extract the page content containing only the IP of the incoming
        # request and print it
        body_element = await page.find_element(By.CSS_SELECTOR, "body")
        body_text = await body_element.get_element_text()
        print(f"Current IP address: {body_text}")

# Execute the async scraping function
asyncio.run(main())

Chaque fois que vous exécutez ce script, vous verrez une adresse IP de sortie différente, grâce à la rotation du proxy de Bright Data.

Remarque: normalement, l’option --proxy-server de Chrome ne prend pas en charge les serveurs mandataires authentifiés. Cependant, le gestionnaire de proxy avancé de Pydoll passe outre cette limitation, ce qui vous permet d’utiliser des serveurs proxy protégés par un mot de passe.

Avec les proxies rotatifs de Bright Data, la rotation du proxy Pydoll est simple, fiable et évolutive !

Alternatives à Pydoll pour le Web Scraping

Pydoll est sans aucun doute une bibliothèque de scraping web puissante, en particulier pour automatiser les navigateurs avec des fonctions intégrées de contournement des robots. Cependant, ce n’est pas le seul outil dans le jeu.

Vous trouverez ci-dessous quelques alternatives solides à Pydoll qui méritent d’être prises en considération :

• SeleniumBase: Un cadre Python construit au-dessus des API Selenium/WebDriver, offrant un ensemble d’outils de qualité professionnelle pour l’automatisation du web. Il prend tout en charge, des tests de bout en bout aux flux de travail de scraping avancés.
• ChromeDriver non détecté: Une version corrigée de ChromeDriver conçue pour échapper à la détection par les services anti-bots populaires comme Imperva, DataDome et Distil Networks. Idéal pour le scraping furtif lors de l’utilisation de Selenium.

Si vous êtes à la recherche d’une solution de scraping web plus généraliste qui fonctionne sur n’importe quel site web et prend en charge plusieurs langages de programmation, consultez nos services de scraping:

• Navigateur de scraping: Un navigateur compatible avec Selenium, Playwright et Puppeteer, avec des capacités de déverrouillage intégrées.
• Web Scraper APIs: API préconfigurées pour l’extraction de données structurées à partir de plus de 100 domaines majeurs.
• Web Unlocker: Une API tout-en-un qui gère le déverrouillage des sites dotés de protections anti-bots.
• SERP API: Une API spécialisée qui déverrouille les résultats des moteurs de recherche et extrait des données SERP complètes.

Conclusion

Dans ce tutoriel sur l’intégration de proxy, vous avez appris ce qu’est Pydoll et comment il fonctionne. Nous avons exploré comment l’utiliser pour le web scraping sur un site web alimenté par JavaScript et nous avons vu comment remédier à sa principale limitation grâce à l’intégration de proxy.
par l’intégration d’un proxy.

Vous avez également compris pourquoi l’utilisation de Pydoll sans mécanisme de rotation d’IP peut conduire à des résultats peu fiables. Pour des performances stables, une sécurité renforcée et une évolutivité, vous devez choisir un fournisseur de proxy de confiance. Gagnez du temps et de l’énergie en vous adressant directement au meilleur fournisseur de proxy du marché, Bright Data.

Créez un compte et commencez à tester nos proxies gratuitement dès aujourd’hui !