--- title: "Guide du scraping web avec SeleniumBase en 2026" slug: web-scraping-with-seleniumbase date: 2026-02-17T09:14:45+00:00 modified: 2026-02-17T09:14:47+00:00 permalink: https://brightdata.fr/blog/donnees-web/web-scraping-with-seleniumbase type: blog --- [ Blog ](https://brightdata.fr/blog "Blog") / [Données Web](https://brightdata.fr/blog/donnees-web) [Données Web](https://brightdata.fr/blog/donnees-web) # Guide du scraping web avec SeleniumBase en 2026 Simplifiez le Scraping web avec SeleniumBase grâce à ses fonctionnalités avancées et son guide étape par étape. 24 min de lecture [ ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![Guide to Web Scraping With SeleniumBase blog image](https://media.brightdata.fr/2025/01/Guide-to-Web-Scraping-With-SeleniumBase.svg) Dans ce guide, vous apprendrez : - Qu’est-ce que SeleniumBase et pourquoi est-il utile pour le Scraping web ? - Comment il se compare à Selenium vanilla - Les fonctionnalités et les avantages offerts par SeleniumBase - Comment l’utiliser pour créer un Scraper simple - Comment l’utiliser pour des cas d’utilisation plus complexes C’est parti ! ## Qu’est-ce que SeleniumBase ? [SeleniumBase](https://seleniumbase.com/) est un framework Python pour l’automatisation des navigateurs. Basé sur les API Selenium/WebDriver, il fournit une boîte à outils professionnelle pour l’automatisation web. Il prend en charge un large éventail de tâches, du test au scraping. SeleniumBase est une bibliothèque tout-en-un pour tester des pages web, automatiser des workflows et faire évoluer des opérations basées sur le web. Elle est dotée de fonctionnalités avancées telles que le contournement des CAPTCHA, la détection des bots et des outils d’amélioration de la productivité. ## SeleniumBase vs Selenium : comparaison des fonctionnalités et des API Pour mieux comprendre les *raisons* qui ont motivé la création de SeleniumBase, il est judicieux de le comparer directement à la version vanilla de Selenium, l’outil sur lequel il est basé. Pour une comparaison rapide entre Selenium et SeleniumBase, consultez le tableau récapitulatif ci-dessous : **Fonctionnalité****SeleniumBase****Selenium****Exécuteurs de tests intégrés**S’intègre à `pytest`, `pynose` et `behave`Nécessite une configuration manuelle pour l’intégration des tests**Gestion des pilotes**Télécharge automatiquement le pilote de navigateur correspondant à la version du navigateurNécessite le téléchargement et la configuration manuels du pilote**Logique d’automatisation Web**Combine plusieurs étapes en un seul appel de méthodeNécessite plusieurs lignes de code pour une fonctionnalité similaire**Gestion des sélecteurs**Détecte automatiquement les sélecteurs CSS ou XPathNécessite la définition explicite des types de sélecteurs dans les appels de méthode**Gestion des délais d’expiration**Applique des délais d’attente par défaut pour éviter les échecsLes méthodes échouent immédiatement si les délais d’expiration ne sont pas explicitement définis**Sorties d’erreur**Fournit des messages d’erreur clairs et lisibles pour faciliter le débogageGénère des journaux d’erreurs détaillés et moins interprétables**Tableaux de bord et rapports**Comprend des tableaux de bord, des rapports et des captures d’écran des échecs intégrésPas de tableaux de bord ni de fonctionnalités de rapport intégrés**Applications GUI de bureau**Offre des outils visuels pour l’exécution des testsNe dispose pas d’outils GUI de bureau pour l’exécution des tests**Enregistreur de tests**Enregistreur de tests intégré pour créer des scripts à partir d’actions manuelles dans le navigateurNécessite la rédaction manuelle de scripts**Gestion des cas de test**Fournit CasePlans pour organiser les tests et documenter les étapes directement dans le cadrePas d’outils intégrés de gestion des cas de test**Prise en charge des applications de données**Comprend ChartMaker pour générer du JavaScript à partir de Python afin de créer des applications de donnéesPas d’outils supplémentaires pour créer des applications de donnéesIl est temps d’examiner les différences ! ### Exécuteurs de tests intégrés SeleniumBase s’intègre à des exécuteurs de tests populaires tels que `pytest`, `pynose` et `behave`. Ces outils offrent une structure organisée, une découverte et une exécution transparentes des tests, un suivi de l’état des tests (par exemple, réussis, échoués ou ignorés) et des options de ligne de commande pour personnaliser les paramètres tels que la sélection du navigateur. Avec Selenium vanilla, vous devriez implémenter manuellement un analyseur d’options ou vous fier à des outils tiers pour configurer les tests à partir de la ligne de commande. ### Gestion améliorée des pilotes Par défaut, SeleniumBase télécharge une version de pilote compatible qui correspond à la version principale de votre navigateur. Vous pouvez remplacer cette option en utilisant l’option `--driver-version=VER` dans votre commande `pytest`. Par exemple : ```none pytest my_script.py --driver-version=114 ``` Selenium vous oblige à télécharger et à configurer manuellement le pilote approprié. Dans ce cas, vous êtes responsable de la compatibilité avec la version du navigateur. ### Méthodes multi-actions SeleniumBase combine plusieurs étapes en une seule méthode pour simplifier l’automatisation Web. Par exemple, la méthode `driver.type(selector, text)` effectue les opérations suivantes : 1. Attend que l’élément soit visible 2. Attend que l’élément soit interactif 3. Efface tout texte existant 4. Saisit le texte fourni 5. Soumet si le texte se termine par ` « n »` Avec Selenium brut, reproduire la même logique nécessiterait quelques lignes de code. ### Gestion simplifiée des sélecteurs SeleniumBase peut automatiquement faire la différence entre [les sélecteurs CSS et les expressions XPath](/blog/web-data/xpath-vs-css-selectors). Il n’est donc plus nécessaire de spécifier explicitement les types de sélecteurs avec `By.CSS_SELECTOR` ou `By.XPATH`. Cependant, vous pouvez toujours fournir le type explicitement si vous le souhaitez. Exemple avec SeleniumBase : ```none driver.click("button.submit") # Détecte automatiquement comme sélecteur CSS driver.click("//button[@class='submit']") # Détecte automatiquement comme XPath ``` Le code équivalent en Selenium vanilla est : ```none driver.find_element(By.CSS_SELECTOR, "button.submit").click() driver.find_element(By.XPATH, "//button[@class='submit']").click() ``` ### Valeurs de délai d’attente par défaut et personnalisées SeleniumBase applique automatiquement un délai d’attente par défaut de 10 secondes aux méthodes, garantissant ainsi que les éléments ont le temps de se charger. Cela évite les échecs immédiats, qui sont fréquents dans Selenium brut. Vous pouvez également définir des valeurs de délai d’attente personnalisées directement dans les appels de méthode, comme dans l’exemple ci-dessous : ```none driver.click("button", timeout=20) ``` Le code Selenium équivalent serait beaucoup plus verbeux et complexe : ```none WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.CSS_SELECTOR, "button"))).click() ``` ### Sorties d’erreurs claires SeleniumBase fournit des messages d’erreur clairs et faciles à lire lorsque les scripts échouent. En revanche, Selenium brut génère souvent des journaux d’erreurs verbeux et moins interprétables, ce qui nécessite des efforts supplémentaires pour le débogage. ### Tableaux de bord, rapports et captures d’écran SeleniumBase comprend des fonctionnalités permettant de générer des tableaux de bord et des rapports pour les exécutions de tests. Il enregistre également des captures d’écran des échecs dans le dossier `./latest_logs/` pour faciliter le débogage. Raw Selenium ne dispose pas de ces fonctionnalités prêtes à l’emploi. ### Fonctionnalités supplémentaires Par rapport à Selenium, SeleniumBase comprend : - Des applications GUI de bureau pour exécuter des tests visuellement, telles que [SeleniumBase Commander](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/commander.md) pour `pytest` et [SeleniumBase Behave GUI](https://github.com/seleniumbase/SeleniumBase/blob/master/examples/behave_bdd/ReadMe.md) pour `behave`. - Un [enregistreur/générateur de tests](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/recorder_mode.md) intégré pour créer des scripts de test basés sur des actions manuelles du navigateur. Cela réduit considérablement l’effort nécessaire pour écrire des tests pour des workflows complexes. - Un logiciel de gestion des cas de test appelé [CasePlans](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/case_plans.md) pour organiser les tests et documenter les descriptions des étapes directement dans le cadre. - Des outils tels que [ChartMaker](https://github.com/seleniumbase/SeleniumBase/blob/master/examples/chart_maker/ReadMe.md) pour créer des applications de données en générant du code JavaScript à partir de Python. Cela en fait une solution polyvalente qui va au-delà de l’automatisation standard des tests. ## SeleniumBase : fonctionnalités, méthodes et options CLI Découvrez ce qui rend SeleniumBase si spécial en explorant ses capacités et son API. ### Fonctionnalités Voici une liste de certaines des fonctionnalités les plus pertinentes de SleniumBase : - Comprend un mode enregistreur pour générer instantanément des tests de navigateur en Python. - Prend en charge plusieurs navigateurs, onglets, iframes et Proxys dans le même test. - Comprend un logiciel de gestion des cas de test avec la technologie Markdown. - Mécanisme d’attente intelligent qui améliore automatiquement la fiabilité et réduit les tests instables. - Compatible avec `pytest`, `unittest`, `nose` et `behave` pour la découverte et l’exécution des tests. - Comprend des outils de journalisation avancés pour les tableaux de bord, les rapports et les captures d’écran. - Peut exécuter des tests en mode Headless pour masquer l’interface du navigateur. - Prend en charge l’exécution de tests multithreads sur des navigateurs parallèles. - Permet d’exécuter des tests à l’aide de l’émulateur d’appareil mobile de Chromium. - Prend en charge l’exécution de tests via un Proxy, même authentifié. - Personnalise la chaîne user-agent du navigateur pour les tests. - Empêche la détection par les sites web qui bloquent l’automatisation Selenium. - S’intègre à selenium-wire pour inspecter les requêtes réseau du navigateur. - Interface de ligne de commande flexible pour des options d’exécution de tests personnalisées. - Fichier de configuration global pour la gestion des paramètres de test. - Prend en charge les intégrations avec GitHub Actions, Google Cloud, Azure, S3 et Docker. - Prend en charge l’exécution de JavaScript à partir de Python. - Peut interagir avec les éléments Shadow DOM en utilisant `::shadow` dans les sélecteurs CSS. Pour[consulter](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/features_list.md) la liste complète,[consultez la documentation](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/features_list.md). N’oubliez pas de lire notre blog sur l’utilisation de [SeleniumBase avec des Proxies](/blog/proxy-101/seleniumbase-with-proxies). ### Méthodes Vous trouverez ci-dessous une liste des méthodes SeleniumBase les plus utiles : - `driver.open(url)`: navigue dans la fenêtre du navigateur vers l’URL spécifiée. - `driver.go_back()`: revient à l’URL précédente. - `driver.type(selector, text)`: met à jour le champ identifié par le sélecteur avec le texte spécifié. - `driver.click(selector)`: cliquer sur l’élément identifié par le sélecteur. - `driver.click_link(link_text)`: clique sur le lien contenant le texte spécifié. - `driver.select_option_by_text(dropdown_selector, option)`: sélectionne une option dans un menu déroulant à partir du texte visible. - `driver.hover_and_click(hover_selector, click_selector)`: survole un élément et clique sur un autre. - `driver.drag_and_drop(drag_selector, drop_selector)`: faire glisser un élément et le déposer sur un autre élément. - `driver.get_text(selector)`: Obtenir le texte de l’élément spécifié. - `driver.get_attribute(selector, attribute)`: Obtenir l’attribut spécifié d’un élément. - `driver.get_current_url()`: Obtenir l’URL de la page actuelle. - `driver.get_page_source()`: récupère le code source HTML de la page actuelle. - `driver.get_title()`: Obtenir le titre de la page actuelle. - `driver.switch_to_frame(frame)`: Basculer vers le conteneur iframe spécifié. - `driver.switch_to_default_content()`: Quitter le conteneur iframe et revenir au document principal. - `driver.open_new_window()`: ouvre une nouvelle fenêtre de navigateur dans la même session. - `driver.switch_to_window(window)`: bascule vers la fenêtre de navigateur spécifiée. - `driver.switch_to_default_window()`: revenir à la fenêtre de navigateur d’origine. - `driver.get_new_driver(OPTIONS)`: ouvre une nouvelle session de pilote avec les options spécifiées. - `driver.switch_to_driver(driver)`: bascule vers le pilote de navigateur spécifié. - `driver.switch_to_default_driver()`: revenir au pilote de navigateur d’origine. - `driver.wait_for_element(selector)`: Attendre que l’élément spécifié soit visible. - `driver.is_element_visible(selector)`: Vérifie si l’élément spécifié est visible. - `driver.is_text_visible(text, selector)`: Vérifie si le texte spécifié est visible dans un élément. - `driver.sleep(seconds)`: Met l’exécution en pause pendant la durée spécifiée. - `driver.save_screenshot(name)`: Enregistrer une capture d’écran au format `.png` avec le nom donné. - `driver.assert_element(selector)`: Vérifie que l’élément spécifié est visible. - `driver.assert_text(text, selector)`: vérifie que le texte spécifié est présent dans l’élément. - `driver.assert_exact_text(text, selector)`: vérifie que le texte spécifié correspond exactement à celui de l’élément. - `driver.assert_title(title)`: vérifie que le titre de la page actuelle correspond au titre spécifié. - `driver.assert_downloaded_file(file)`: vérifie que le fichier spécifié a été téléchargé. - `driver.assert_no_404_errors()`: vérifie qu’il n’y a pas de liens rompus sur la page. - `driver.assert_no_js_errors()`: vérifie qu’il n’y a pas d’erreurs JavaScript sur la page. Pour obtenir la liste complète, [consultez la documentation](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/method_summary.md). ### Options CLI SeleniumBase étend `pytest` avec les options de ligne de commande suivantes : - `--browser=BROWSER`: définit le navigateur Web (par défaut : « chrome »). - `--chrome`: raccourci pour `--browser=chrome`. - `--edge`: raccourci pour `--browser=edge`. - `--firefox`: raccourci pour `--browser=firefox`. - `--safari`: raccourci pour `--browser=safari`. - `--settings-file=FILE`: Remplace les paramètres SeleniumBase par défaut. - `--env=ENV`: définit l’environnement de test, accessible via `driver.env`. - `--account=STR`: définit le compte, accessible via `driver.account`. - `--data=STRING`: données de test supplémentaires, accessibles via `driver.data`. - `--var1=STRING`: données de test supplémentaires, accessibles via `driver.var1`. - `--var2=STRING`: données de test supplémentaires, accessibles via `driver.var2`. - `--var3=STRING`: données de test supplémentaires, accessibles via `driver.var3`. - `--variables=DICT`: données de test supplémentaires, accessibles via `driver.variables`. - `--proxy=SERVER:PORT`: se connecter à un serveur Proxy. - `--proxy=USERNAME:PASSWORD@SERVER:PORT`: Utilisation d’un Proxy authentifié. - `--proxy-bypass-list=STRING`: hôtes à contourner (par exemple, « \*.foo.com »). - `--proxy-pac-url=URL`: connexion via l’URL PAC. - `--proxy-pac-url=USERNAME:PASSWORD@URL`: Proxy authentifié avec URL PAC. - `--proxy-driver`: Utiliser un Proxy pour le téléchargement du pilote. - `--multi-proxy`: autoriser plusieurs Proxys authentifiés en multithreading. - `--agent=STRING`: Modifier la chaîne User-Agent du navigateur. - `--mobile`: active l’émulateur d’appareil mobile. - `--metrics=STRING`: définit les métriques mobiles (par exemple, « CSSWidth,CSSHeight,PixelRatio »). - `--chromium-arg="ARG=N,ARG2"`: définit les arguments Chromium. - `--firefox-arg="ARG=N,ARG2"`: définit les arguments Firefox. - `--firefox-pref=SET`: définit les préférences Firefox. - `--extension-zip=ZIP`: charge les fichiers `.``zip/.crx` de l’extension Chrome. - `--extension-dir=DIR`: charge les répertoires d’extension Chrome. - `--disable-features="F1,F2"`: désactiver les fonctionnalités. - `--binary-location=PATH`: Définit le chemin d’accès au fichier binaire Chromium. - `--driver-version=VER`: Définit la version du pilote. - `--headless`: mode sans affichage par défaut. - `--headless1`: Utilise l’ancien mode sans affichage de Chrome. - `--headless2`: Utiliser le nouveau mode sans affichage de Chrome. - `--headed`: active le mode GUI sous Linux. - `--xvfb`: exécute les tests avec Xvfb sous Linux. - `--locale=LOCALE_CODE`: définit la langue du navigateur. - `--reuse-session`: réutilise la session du navigateur pour tous les tests. - `--reuse-class-session`: réutilise la session pour les tests de classe. - `--crumbs`: Supprimer les cookies entre les sessions réutilisées. - `--disable-cookies`: désactive les cookies. - `--disable-js`: désactive JavaScript. - `--disable-csp`: désactiver la politique de sécurité du contenu. - `--disable-ws`: désactiver la sécurité Web. - `--enable-ws`: Activer la sécurité Web. - `--log-cdp`: enregistrer les événements du protocole Chrome DevTools (CDP). - `--remote-debug`: synchroniser avec Chrome Remote Debugger. - `--visual-baseline`: définit la base visuelle pour les tests de mise en page. - `--timeout-multiplier=MULTIPLIER`: multiplier les valeurs de délai d’expiration par défaut. Consultez la liste complète des définitions des options de ligne de commande [dans la documentation](https://github.com/seleniumbase/SeleniumBase/blob/master/seleniumbase/plugins/pytest_plugin.py). ## Utilisation de SeleniumBase pour le Scraping web : guide étape par étape Suivez ce tutoriel étape par étape pour apprendre à créer un Scraper SeleniumBase afin de récupérer des données à partir du bac à sable [Quotes to Scrape](https://quotes.toscrape.com/): ![Quotes to Scrape sandbox to practice web scraping](https://media.brightdata.fr/2025/01/image-11.png)Pour un tutoriel similaire utilisant Selenium vanilla, consultez notre guide sur [le Scraping web avec Selenium](/blog/how-tos/using-selenium-for-web-scraping). ### Étape n° 1 : Initialisation du projet Avant de commencer, assurez-vous que Python 3 est installé sur votre ordinateur. Sinon, [téléchargez-le](https://www.python.org/downloads/) et installez-le. Ouvrez le terminal et lancez la commande ci-dessous pour créer un répertoire pour votre projet : ```none mkdir seleniumbase-Scraper ``` `seleniumbase-scraper` contiendra votre Scraper SeleniumBase. Naviguez à l’intérieur et initialisez un [environnement virtuel](https://docs.python.org/3/library/venv.html): ```none cd seleniumbase-Scraper python -m venv env ``` Ensuite, chargez le dossier du projet dans votre IDE Python préféré. [Visual Studio Code avec l’extension Python](https://code.visualstudio.com/docs/languages/python) ou [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/#section=windows) feront l’affaire. Créez un fichier `scraper.py` dans le répertoire du projet, qui devrait maintenant contenir cette structure de fichiers : ![Creating a new scraper.py file in the project's folder](https://media.brightdata.fr/2025/01/image-12.png)`scraper.py` contiendra bientôt votre logique de scraping. Activez l’environnement virtuel dans le terminal de l’IDE. Sous Linux ou macOS, utilisez la commande ci-dessous : ```none ./env/bin/activate ``` De manière équivalente, sous Windows, exécutez : ```none env/Scripts/activate ``` Dans l’environnement activé, lancez cette commande pour [installer SeleniumBase](https://pypi.org/project/seleniumbase/): ```none pip install seleniumbase ``` Parfait ! Vous disposez désormais d’un environnement Python pour le Scraping web avec SeleniumBase. ### Étape n° 2 : configuration du test SeleniumBase Bien que SeleniumBase prenne en charge la syntaxe `pytest` pour la création de tests, un [bot de Scraping web](/blog/how-tos/what-is-a-scraping-bot) n’est pas un script de test. Vous pouvez toujours profiter de toutes les options d’extension de ligne de commande `pytest` de SeleniumBase en utilisant la [syntaxe`SB`](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/syntax_formats.md#-21-seleniumbase-sb-python-context-manager): ```none from seleniumbase import SB with SB() as sb: pass # Logique de scraping... ``` Vous pouvez désormais exécuter votre test avec : ```none python3 Scraper.py ``` **Remarque**: sous Windows, remplacez `python3` par `python`. Pour l’exécuter en mode headless, lancez : ```none python3 Scraper.py --headless ``` N’oubliez pas que vous pouvez combiner plusieurs options de ligne de commande. ### Étape n° 3 : se connecter à la page cible Utilisez la méthode `open()` pour demander au navigateur contrôlé de visiter votre page cible : ```none sb.open("https://quotes.toscrape.com/") ``` Si vous exécutez le script de test de scraping en mode headed, voici ce que vous verrez pendant une fraction de seconde : ![The window you'll see for a second if you are using a headed mode](https://media.brightdata.fr/2025/01/image-13.png)Notez que, contrairement à Selenium vanilla, vous n’avez pas besoin de fermer manuellement le pilote. SeleniumBase s’en chargera pour vous. ### Étape n° 4 : sélectionnez les éléments de citation Ouvrez la page cible en mode incognito dans votre navigateur et inspectez un élément de citation : ![inspecting a quote element in incognito](https://media.brightdata.fr/2025/01/image-14.png)Comme la page contient plusieurs citations, créez un tableau `de citations` pour stocker les données extraites : ```none quotes = [] ``` Dans la section DevTools ci-dessus, vous pouvez voir que toutes les citations peuvent être sélectionnées à l’aide du sélecteur CSS `.quote`. Utilisez `find_elements()` pour les sélectionner toutes : ```none quote_elements = sb.find_elements(".quote") ``` Ensuite, préparez-vous à itérer sur les éléments et à extraire les données de chaque élément de citation. Ajoutez les données extraites à un tableau : ```none for quote_element in quote_elements: # Logique de scraping... ``` Parfait ! La logique de récupération de haut niveau est maintenant prête. ### Étape n° 5 : extraire les données des citations Inspectez un seul élément de citation : ![Inspecting a single quote element ](https://media.brightdata.fr/2025/01/image-15.png)Notez que vous pouvez extraire : - Le texte de la citation à partir de `.text` - L’auteur de la citation à partir de `.author` - Les balises de citation à partir de `.tag` Sélectionnez chaque nœud et extrayez les données à partir de ceux-ci avec l’attribut `text`: ```none text_element = quote_element.find_element(By.CSS_SELECTOR, ".text") text = text_element.text.replace("“", "").replace("”", "") author_element = quote_element.find_element(By.CSS_SELECTOR, ".author") author = author_element.text tags = [] tag_elements = quote_element.find_elements(By.CSS_SELECTOR, ".tag") for tag_element in tag_elements: tag = tag_element.text tags.append(tag) ``` Notez que `find_elements()` renvoie des objets Selenium `WebElement` vanilla. Ainsi, pour sélectionner des éléments à l’intérieur, vous devez utiliser les méthodes natives de Selenium. C’est pourquoi vous devez spécifier `By.CSS_SELECTOR` comme localisateur. Veillez à importer `By` au début de votre script : ```none from selenium.webdriver.common.by import By ``` Notez que le scraping des balises nécessite une boucle, car une seule citation peut comporter une ou plusieurs balises. Observez également l’utilisation de la méthode `replace()` pour supprimer les guillemets doubles spéciaux qui entourent le texte. ### Étape n° 6 : remplir le tableau Quotes Remplissez un nouvel objet `quotes` avec les données récupérées et ajoutez-le à `quotes`: ```none quote = { "text": text, "author": author, "tags": tags } quotes.append(quote) ``` Incroyable ! La logique de scraping SelenumBase est terminée. ### Étape n° 7 : implémenter la logique de crawling N’oubliez pas que le site cible contient plusieurs pages. Pour passer à la page suivante, cliquez sur le bouton « Suivant → » en bas : ![Inspecting the "next" button of the pagination ](https://media.brightdata.fr/2025/01/image-16.png)Sur la dernière page, ce bouton n’apparaîtra pas. Pour implémenter [le crawling web](/blog/leadership/web-crawling-vs-web-scraping) et scraper toutes les pages, placez votre logique de scraping dans une boucle qui clique sur le bouton « Suivant → » et s’arrête lorsque le bouton n’est plus disponible : ```none while sb.is_element_present(".next"): # Logique de scraping... # Visiter la page suivante sb.click(".next a") ``` Notez l’utilisation de la méthode spéciale SleniumBae `is_element_present()` pour vérifier si le bouton est présent ou non. Parfait ! Votre Scraper SeleniumBase va maintenant parcourir l’ensemble du site. ### Étape n° 8 : exporter les données récupérées Exportez les données récupérées entre `guillemets` dans un fichier CSV comme suit : ```none with open("quotes.csv", mode="w", newline="", encoding="utf-8") as file: writer = csv.DictWriter(file, fieldnames=["text", "author", "tags"]) writer.writeheader() # Aplatir les objets citations pour l'écriture CSV for quote in quotes: writer.writerow({ "text": quote["text"], "author": quote["author"], "tags": ";".join(quote["tags"]) }) ``` N’oubliez pas d’importer [`csv`](https://docs.python.org/3/library/csv.html) depuis la bibliothèque standard Python : ```none import csv ``` ### Étape n° 9 : assembler le tout Votre fichier `script.py` devrait maintenant contenir le code suivant : ```none from seleniumbase import SB from selenium.webdriver.common.by import By import csv with SB() as sb: # Se connecter à la page cible sb.open("https://quotes.toscrape.com/") # Où stocker les données récupérées quotes = [] # Parcourir toutes les pages de citations while sb.is_element_present(".next"): # Sélectionner tous les éléments de citation sur la page quote_elements = sb.find_elements(".quote") # Parcourir ces éléments et extraire les données pour chaque élément de citation for quote_element in quote_elements: # Logique d'extraction des données text_element = quote_element.find_element(By.CSS_SELECTOR, ".text") text = text_element.text.replace("“", "").replace("”", "") author_element = quote_element.find_element(By.CSS_SELECTOR, ".author") author = author_element.text tags = [] tag_elements = quote_element.find_elements(By.CSS_SELECTOR, ".tag") for tag_element in tag_elements: tag = tag_element.text tags.append(tag) # Remplir un nouvel objet citation avec les données extraites quote = { "text": text, "author": author, "tags": tags } # L'ajouter à la liste des citations extraites quotes.append(quote) # Aller à la page suivante sb.click(".next a") # Exporter les données récupérées au format CSV with open("quotes.csv", mode="w", newline="", encoding="utf-8") as file: writer = csv.DictWriter(file, fieldnames=["text", "author", "tags"]) writer.writeheader() # Aplatir les objets citation pour l'écriture CSV for quote in quotes: writer.writerow({ "text": quote["text"], "author": quote["author"], "tags": ";".join(quote["tags"]) }) ``` Exécutez le Scraper SeleniumBase en mode headless avec : ```none python3 script.py --headless ``` Après quelques secondes, un fichier `quotes.csv` apparaîtra dans le dossier du projet. Ouvrez-le et vous verrez : ![The final result with all the data that you will see](https://media.brightdata.fr/2025/01/image-17.png)Et voilà ! Votre script de Scraping web SeleniumBase fonctionne à merveille. ## Cas d’utilisation avancés du scraping avec SeleniumBase Maintenant que vous connaissez les bases de SeleniumBase, vous êtes prêt à explorer des scénarios plus complexes. ### Automatisation du remplissage et de la soumission de formulaires **Remarque : Bright Data n’effectue pas de scraping derrière une connexion.** SeleniumBase vous permet également d’interagir avec les éléments d’une page comme le ferait un utilisateur humain. Par exemple, supposons que vous deviez interagir avec un formulaire de connexion comme celui ci-dessous : ![Quotes to Scrape login page](https://media.brightdata.fr/2025/01/image-18.png)Votre objectif est de remplir les champs « Nom d’utilisateur » et « Mot de passe », puis de soumettre le formulaire en cliquant sur le bouton « Connexion ». Vous pouvez y parvenir avec un test SeleniumBase comme suit : ```none # login.py from seleniumbase import BaseCase BaseCase.main(__name__, __file__) class LoginTest(BaseCase): def test_submit_login_form(self): # Visitez la page cible self.open("https://quotes.toscrape.com/login") # Remplir le formulaire self.type("#username", "test") self.type("#password", "test") # Soumettre le formulaire self.click("input[type="submit"]") # Vérifier que vous êtes sur la bonne page self.assert_text("Top Ten tags") ``` Cet exemple est idéal pour créer un test, alors notez l’utilisation de la classe `BaseCase`. Cela vous permet de créer des tests `pytest`. Exécutez le test à l’aide de cette commande : ```none pytest login.py ``` Vous verrez le navigateur s’ouvrir, charger la page de connexion, remplir le formulaire, le soumettre, puis vérifier que le texte donné apparaît sur la page. Le résultat dans le terminal ressemblera à ceci : ```none login.py . [100 %] ======================================== 1 réussi en 11,20 s ========================================= ``` ### Contourner les technologies anti-bot simples De nombreux sites mettent en œuvre [des mesures anti-scraping](/blog/web-data/anti-scraping-techniques) avancées pour empêcher les bots d’accéder à leurs données. Ces techniques comprennent les défis CAPTCHA, les limites de débit, l’empreinte digitale du navigateur, etc. Pour scraper efficacement des sites web sans être bloqué, vous devez contourner ces protections. SeleniumBase offre une fonctionnalité spéciale appelée « mode UC » ([Undetected-Chromedriver Mode](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/uc_mode.md)), qui aide les robots de scraping à ressembler davantage à des utilisateurs humains. Cela leur permet d’échapper à la détection par les services anti-bots, qui pourraient autrement bloquer directement le robot de scraping ou déclencher des CAPTCHA. Le mode UC est basé sur [`undetected-chromedriver`](https://github.com/ultrafunkamsterdam/undetected-chromedriver) et comprend plusieurs mises à jour, corrections et améliorations, telles que : - Rotation automatique des agents utilisateurs pour éviter la détection. - Configuration automatique des arguments Chromium selon les besoins. - Méthodes spéciales `uc_*()` pour contourner les CAPTCHA. Voyons maintenant comment utiliser le mode UC dans SeleniumBase pour contourner les défis anti-bot. Pour cette démonstration, vous verrez comment accéder à la page anti-bot du [site Scraping Course](https://www.scrapingcourse.com/antibot-challenge): ![Basic Cloudflare CAPTCHA on the Scraping Course website](https://media.brightdata.fr/2025/01/image-19.png)Pour contourner les mesures anti-bot et gérer le CAPTCHA, activez le mode UC et utilisez les méthodes `uc_open_with_reconnect()` et `uc_gui_click_captcha()`: ```none from seleniumbase import SB with SB(uc=True) as sb: # Page cible avec mesures anti-bot url = "https://www.scrapingcourse.com/antibot-challenge" # Ouvrez l'URL en utilisant le mode UC avec un temps de reconnexion de 4 secondes pour éviter la détection initiale. sb.uc_open_with_reconnect(url, reconnect_time=4) # Tenter de contourner le CAPTCHA sb.uc_gui_click_captcha() # Prendre une capture d'écran de la page sb.save_screenshot("screenshot.png") ``` Lancez maintenant le script et vérifiez qu’il fonctionne comme prévu. Étant donné que `uc_gui_click_captcha()` nécessite [PyAutoGUI](https://pyautogui.readthedocs.io/en/latest/) pour fonctionner, SeleniumBase l’installera pour vous lors de la première exécution : ```none PyAutoGUI requis ! Installation en cours... ``` Vous verrez le navigateur cliquer automatiquement sur la case « Vérifiez que vous êtes humain » en déplaçant votre souris. Le fichier `screenshot.png` dans votre dossier de projet affichera : ![Antibot challenge bypass succeeded ](https://media.brightdata.fr/2025/01/image-20.png)Waouh ! Cloudflare a été contourné. ### Contourner les technologies anti-bot complexes Les solutions anti-bot sont de plus en plus sophistiquées, et le mode UC n’est pas toujours efficace. C’est pourquoi SeleniumBase propose également un mode CDP spécial ([Chrome DevTools Protocol Mode](https://github.com/seleniumbase/SeleniumBase/blob/master/examples/cdp_mode/ReadMe.md)). Le mode CDP fonctionne dans le mode UC et permet aux bots d’apparaître plus humains en contrôlant le navigateur via le pilote CDP. Alors que le mode UC standard ne peut pas effectuer d’actions WebDriver lorsque le `pilote` est déconnecté du navigateur, le pilote CDP peut toujours interagir avec le navigateur, surmontant ainsi cette limitation. Le mode CDP est basé sur [`python-cdp`](https://github.com/HyperionGray/python-chrome-devtools-protocol), [`trio-cdp`](https://github.com/HyperionGray/trio-chrome-devtools-protocol) et [`nodriver`](https://github.com/ultrafunkamsterdam/nodriver). Il est conçu pour contourner les solutions anti-bots avancées des sites réels, comme dans l’exemple ci-dessous : ```none from seleniumbase import SB with SB(uc=True, test=True) as sb: # Page cible avec mesures anti-bot avancées url = "https://gitlab.com/users/sign_in" # Visiter la page en mode CDP sb.activate_cdp_mode(url) # Gérer le CAPTCHA sb.uc_gui_click_captcha() # Attendre 2 secondes que la page se recharge et que le pilote reprenne le contrôle sb.sleep(2) # Prendre une capture d'écran de la page sb.save_screenshot("screenshot.png") ``` Le résultat sera le suivant : ![The final result that you will see](https://media.brightdata.fr/2025/01/image-21.png)Et voilà ! Vous êtes désormais un expert en scraping avec SeleniumBase. ## Conclusion Dans cet article, vous avez découvert SeleniumBase, ses fonctionnalités et ses méthodes, ainsi que son utilisation pour le Scraping web. Vous avez commencé par des scénarios basiques, puis vous avez exploré des cas d’utilisation plus complexes. Si les modes UC et CDP sont efficaces pour contourner certaines mesures anti-bot, ils ne sont pas infaillibles. Les sites web peuvent toujours bloquer votre IP si vous effectuez trop de requêtes ou vous mettre au défi avec des CAPTCHA plus complexes qui nécessitent plusieurs actions. Une solution plus efficace consiste à utiliser un outil d’automatisation de navigateur web comme Selenium en combinaison avec un navigateur dédié au scraping, basé sur le cloud et hautement évolutif comme [Navigateur de scraping de Bright Data](/products/scraping-browser). Le Navigateur de scraping est un navigateur qui fonctionne avec Playwright, Puppeteer, Selenium et d’autres. Il fait automatiquement tourner les adresses IP de sortie à chaque requête et peut gérer les empreintes digitales du navigateur, les nouvelles tentatives, [la résolution des CAPTCHA](/products/web-unlocker/captcha-solver) et bien plus encore. Oubliez les blocages et rationalisez vos opérations de scraping. Inscrivez-vous dès maintenant et commencez votre essai gratuit ! Contacter ventesEssai gratuit![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Table des matières Dedicated Scraper APIs & No-Code Scrapers Over 1000 scrapers for all popular domains. Simplify your web scraping. [See pricing](/pricing/web-scraper "See pricing") Just want data? Skip scraping. Hundreds of ready-to-use datasets from all popular domains. [See pricing](/pricing/datasets "See pricing") [ ](https://news.ycombinator.com/submitlink?t=Guide+du+scraping+web+avec+SeleniumBase+en+2026&u=https://brightdata.fr/blog/donnees-web/web-scraping-with-seleniumbase) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Guide+du+scraping+web+avec+SeleniumBase+en+2026&url=https://brightdata.fr/blog/donnees-web/web-scraping-with-seleniumbase) [ ](http://www.reddit.com/submit?title=Guide+du+scraping+web+avec+SeleniumBase+en+2026&url=https://brightdata.fr/blog/donnees-web/web-scraping-with-seleniumbase) ## Vous pourriez aussi être intéressé par [ ![OpenHuman with Bright Data](https://media.brightdata.fr/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.fr/blog/ai/openhuman-with-bright-data "Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data") [AI ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data Intégrez le CLI Bright Data avec OpenHuman pour permettre un accès web prêt pour la production et la collecte de données pour les agents IA. 09-Sep-2026 14 min de lecture ](https://brightdata.fr/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.fr/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.fr/blog/donnees-web/multimodal-web-scraping-with-minimax "Scraping Web Multimodal avec MiniMax") [Données Web ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Scraping Web Multimodal avec MiniMax Associez Bright Data Web Unlocker avec la vision MiniMax M3 pour extraire des données structurées à partir d’images et de captures d’écran de pages web. 09-Sep-2026 5 min de lecture ](https://brightdata.fr/blog/donnees-web/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.fr/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.fr/blog/ai/best-cli-tools-for-codex "Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés") [AI ![Daniel Shashko](https://media.brightdata.fr/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés Les 10 outils CLI qui rendent Codex plus rapide et plus capable, en commençant par le Bright Data CLI pour un accès web réel depuis l’intérieur du sandbox. 06-Sep-2026 24 min de lecture ](https://brightdata.fr/blog/ai/best-cli-tools-for-codex)