L'automatisation du navigateur en Python : Playwright, Selenium et plus encore

Automatisation du navigateur et tests E2E en Python : une comparaison.

Sommaire

Le choix de la bonne pile d’automatisation de navigateur en Python affecte la vitesse, la stabilité et l’entretien. Ce survol compare Playwright vs Selenium vs Puppeteer vs LambdaTest vs ZenRows vs Gauge - avec un accent particulier sur Python, tout en notant où Node.js ou d’autres langages s’intègrent.

Playwright trace viewer Ici, nous avons une capture d’écran du Playwright trace viewer

Quand utiliser lequel

Playwright (Python)
Playwright est une bibliothèque open source d’automatisation de navigateur développée par Microsoft. Elle communique avec Chromium, Firefox et WebKit via le Chrome DevTools Protocol (CDP) ou WebSocket, ce qui vous donne une seule API pour les trois moteurs. Elle inclut l’attente automatique : avant chaque action (clic, remplissage, etc.), elle attend que l’élément soit visible, stable et actionable, ce qui réduit les tests instables et l’usage manuel de sleep ou WebDriverWait. L’installation est minimale (pip install playwright puis playwright install), et l’API Python est de première classe (synchrone et asynchrone). Utilisez-la pour de nouveaux ensembles de tests E2E, le scripting ou l’automatisation (par exemple, construction de serveurs MCP en Python qui contrôlent un navigateur). Pour un tutoriel complet avec des exemples en Python, JavaScript et TypeScript, consultez Playwright : Web Scraping & Testing. Associez-la avec les tests unitaires en Python pour le reste de votre application et utilisez Playwright uniquement pour la couche navigateur. Inconvénients : plus récente que Selenium, donc moins d’intégrations tierces et moins de matériel hérité ; pas de support officiel pour les navigateurs très anciens.

Selenium (Python)
Selenium est le standard établi pour l’automatisation des navigateurs. Le projet Selenium (open source, soutenu par la fondation OpenJS) fournit l’API WebDriver : vous envoyez des commandes à un pilote spécifique au navigateur (ChromeDriver, GeckoDriver, etc.), qui communique avec le navigateur réel. Selenium prend en charge de nombreux langages (Python, Java, C#, JavaScript, etc.) et la plus large gamme de navigateurs, y compris les anciens. Selenium 4+ inclut Selenium Manager, donc vous n’avez plus besoin de télécharger ou de configurer manuellement les pilotes - le client récupère le pilote approprié pour vous. L’API ne fait pas d’attente automatique ; vous utilisez généralement WebDriverWait et les conditions attendues pour éviter les tests instables. Utilisez Selenium lorsque vous gérez des ensembles de tests WebDriver existants, que vous avez besoin de l’écosystème et du support linguistique les plus larges, ou que vous devez supporter des navigateurs anciens. Il s’intègre bien aux modèles de conception Python pour une architecture propre lorsque vous encapsulez le pilote derrière un petit adaptateur. Inconvénients : généralement plus lent et plus fragile que Playwright sans stratégie d’attente soigneusement planifiée ; plus de code redondant.

Puppeteer
Puppeteer est la bibliothèque Node.js de Google pour contrôler Chrome/Chromium (et Edge basé sur Chromium). Elle utilise directement le Chrome DevTools Protocol et est l’option de prédilection pour les équipes JavaScript/TypeScript effectuant uniquement l’automatisation de Chrome, la génération de PDF ou le scraping en Node. Il n’y a aucune liaison officielle Python ; l’API est uniquement Node. Si votre pile est Python, utilisez Playwright (même idée de contrôle CDP, mais avec une API Python de première classe) ou Selenium. Si vous êtes en Node.js et que vous avez besoin uniquement de Chromium, Puppeteer est une option solide et bien documentée. Inconvénients : uniquement Chrome/Chromium ; aucun Firefox ou WebKit ; aucun Python.

LambdaTest
LambdaTest est une plateforme de test cloud commerciale. Vous continuez à écrire les mêmes scripts Selenium ou Playwright (ou Cypress, etc.) localement, mais au lieu de lancer un navigateur local, vous vous connectez au réseau LambdaTest. Ils fournissent des navigateurs réels et des appareils réels (y compris mobiles) en cloud, donc vous pouvez exécuter des tests en parallèle sur de nombreuses combinaisons OS/navigateur/version sans gérer votre propre laboratoire. Vous obtenez un tableau de bord pour les résultats, les vidéos et les logs. Utilisez-le lorsque vous avez besoin d’une couverture multi-navigateurs, d’une exécution en parallèle à grande échelle, ou d’une émulation mobile sans héberger l’infrastructure. Il supporte également Gauge : vous exécutez vos spécifications Gauge sur leur grille Selenium. Inconvénients : payant (avec des tiers gratuits) ; les tests s’exécutent sur le réseau, donc la latence et la disponibilité dépendent de leur service.

ZenRows
ZenRows est un service commercial de scraping web et de détection anti-bot. Son navigateur de scraping est un navigateur cloud que vous contrôlez via Playwright (ou d’autres outils compatibles CDP) : vous connectez votre script à un point de terminaison WebSocket et le navigateur s’exécute côté ZenRows avec des proxys résidentiels, une rotation d’IP, un contournement anti-bot (par exemple Cloudflare, DataDome), et un traitement optionnel des CAPTCHA. Vous n’avez pas à modifier votre logique Playwright - uniquement le point de terminaison du navigateur. Utilisez-le lorsque votre objectif est le scraping et que vous rencontrez des blocages ou des limites de taux ; pour des tests E2E simples sur votre propre application, le Playwright ou le Selenium locaux sont généralement suffisants. Inconvénients : payant ; orienté scraping, pas de grilles de tests générales comme LambdaTest.

Gauge
Gauge est un framework de test open source de Thoughtworks. Il se concentre sur les spécifications et les rapports : vous écrivez des spécifications en Markdown (ou d’autres formats) avec des scénarios et des étapes, et implémentez les étapes en Python (ou Java, JavaScript, etc.) en utilisant Selenium - ou tout autre pilote - pour contrôler le navigateur. Gauge ne remplace pas Selenium ou Playwright ; il s’installe au-dessus d’eux et ajoute de la structure, de la réutilisation et des rapports lisibles. Utilisez-le lorsque vous souhaitez des spécifications BDD, une documentation vivante et des rapports de test clairs sur votre configuration Selenium (ou similaire). LambdaTest supporte l’exécution de tests Gauge sur leur grille. Inconvénients : couche supplémentaire à apprendre et à maintenir ; vous devez toujours choisir et configurer un pilote d’automatisation de navigateur (par exemple Selenium).

Où ils s’exécutent

  • Playwright : Local ou CI ; Python 3.8+ ; Windows, macOS, Linux. Fonctionne également avec des navigateurs cloud/à distance (par exemple ZenRows, LambdaTest) en se connectant à un point de terminaison WebSocket ou CDP.
  • Selenium : Local ou CI ; tout langage avec un client WebDriver ; Selenium Grid ou un fournisseur comme LambdaTest pour l’échelle.
  • Puppeteer : Node.js uniquement ; généralement Chrome/Chromium sur la machine ou dans Docker.
  • LambdaTest : Cloud uniquement ; vous exécutez Selenium/Playwright (ou Gauge sur Selenium) contre leur grille.
  • ZenRows : Navigateur de scraping cloud ; vous le contrôlez depuis Python (par exemple Playwright) ou d’autres outils compatibles CDP.
  • Gauge : S’exécute sur votre machine ou CI ; utilise Selenium (ou un autre pilote) sous le capot ; peut cibler la grille de LambdaTest.

Pour un aperçu rapide des tendances de l’écosystème Python, consultez les projets Python les plus populaires sur GitHub ; de nombreux outils d’automatisation et de test y figurent.

Comment les utiliser en Python

Playwright (Python)

Le package Playwright pour Python fournit à la fois des API synchrones et asynchrones. Les navigateurs sont installés séparément afin que la bibliothèque reste petite et que vous puissiez choisir uniquement les moteurs dont vous avez besoin (Chromium, Firefox, WebKit). Installez et installez les navigateurs :

pip install playwright
playwright install

Exemple synchrone (naviguer, cliquer, lire du texte - Playwright attend automatiquement les éléments) :

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    # Cliquez sur le lien, puis vérifiez le titre (l'attente automatique est intégrée)
    page.get_by_role("link", name="More information...").click()
    heading = page.get_by_role("heading", name="Example Domain").text_content()
    print(heading)
    browser.close()

L’asynchrone est recommandée pour la concurrence et s’intègre bien aux workflows de sortie structurée des LLM ou aux scripts qui effectuent des E/S tout en exécutant le navigateur :

from playwright.async_api import async_playwright
import asyncio

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto("https://example.com")
        print(await page.title())
        await browser.close()

asyncio.run(main())

Pour un cheat sheet Python et une référence de syntaxe, gardez un document local à portée de main.

Selenium (Python)

Le client Python utilise le protocole W3C WebDriver. Selenium 4+ utilise Selenium Manager pour télécharger et gérer automatiquement le pilote correct (ChromeDriver, GeckoDriver, etc.), donc vous n’avez plus besoin de télécharger les pilotes manuellement :

pip install selenium

Exemple de base avec attente explicite (Selenium ne fait pas d’attente automatique ; utilisez WebDriverWait ou les conditions attendues) :

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("https://example.com")
# Attendez que le corps soit présent, puis obtenez le titre
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "body")))
print(driver.title)
driver.quit()

Cliquez et lisez le texte :

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("https://example.com")
link = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.LINK_TEXT, "More information. .."))
)
link.click()
heading = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.CSS_SELECTOR, "h1"))
)
print(heading.text)
driver.quit()

Puppeteer (Node.js ; aucun officiel Python)

Puppeteer est uniquement JavaScript/Node.js - Google ne maintient pas d’API Python. Si vous souhaitez une expérience similaire à Puppeteer en Python, utilisez Playwright (même idée de contrôle Chrome via CDP, mais avec une API Python de première classe et attente automatique). Il existe un port non officiel pyppeteer, mais il n’est pas activement maintenu ; pour de nouveaux travaux Python, Playwright est le meilleur choix. Voici l’exemple Node.js pour que vous puissiez comparer l’API :

npm init -y && npm install puppeteer

const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch({ headless: true });
  const page = await browser.newPage();
  await page.goto("https://example.com");
  console.log(await page.title());
  await page.click("a[href='https://www.iana.org/domains/example']");
  const text = await page.$eval("h1", (el) => el.textContent);
  console.log(text);
  await browser.close();
})();

LambdaTest (Python : Selenium)

Vous utilisez la même API Selenium ; le seul changement est de vous connecter au hub WebDriver distant de LambdaTest au lieu d’un pilote local. Définissez les capacités (navigateur, OS, nom de build, etc.) et transmettez votre nom d’utilisateur et votre clé d’accès depuis le tableau de bord LambdaTest :

from selenium import webdriver

options = webdriver.ChromeOptions()
options.browser_version = "latest"
options.platform_name = "Windows 11"

lt_caps = {
    "lt:options": {
        "username": "YOUR_LT_USERNAME",
        "accessKey": "YOUR_LT_ACCESS_KEY",
        "build": "Playwright-Selenium-Compare",
        "name": "Selenium on LambdaTest",
    }
}
options.set_capability("lt:options", lt_caps["lt:options"])

driver = webdriver.Remote(
    command_executor="https://YOUR_LT_USERNAME:YOUR_LT_ACCESS_KEY@hub.lambdatest.com/wd/hub",
    options=options,
)
driver.get("https://example.com")
print(driver.title)
driver.quit()

LambdaTest (Python : Playwright)

Playwright peut se connecter à un navigateur distant via le CDP (Chrome DevTools Protocol). LambdaTest expose un point de terminaison CDP pour chaque exécution de test ; vous vous connectez à celui-ci au lieu de lancer un navigateur local. Consultez les documents LambdaTest pour le format exact de l’URL CDP et l’authentification :

from playwright.sync_api import sync_playwright

# LambdaTest fournit un point de terminaison CDP par exécution ; utilisez leurs documents pour l'obtenir
CDP_URL = "wss://cdp.lambdatest.com/playwright?capabilities=..."  # depuis le tableau de bord LT

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(CDP_URL)
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()

ZenRows + Playwright (Python)

Le navigateur de scraping ZenRows est compatible CDP, donc vous utilisez Playwright’s connect_over_cdp() avec leur URL WebSocket. Le navigateur s’exécute en cloud ZenRows avec leurs proxys et traitement anti-bot ; votre script reste le même à l’exception de la manière dont vous vous connectez. Seule l’étape de lancement change :

from playwright.sync_api import sync_playwright

ZENROWS_WS = "wss://browser.zenrows.com?apikey=YOUR_ZENROWS_API_KEY"

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(ZENROWS_WS)
    page = browser.new_page()
    page.goto("https://example.com")
    html = page.content()
    print(html[:500])
    browser.close()

Ensuite, transmettez le HTML résultant à votre propre parseur ou, par exemple, convertir HTML en Markdown avec Python pour le traitement ultérieur.

Gauge + Selenium (Python)

Gauge garde les spécifications en Markdown (ou d’autres formats) et les implémentations des étapes en Python. Chaque étape peut appeler Selenium (ou tout autre pilote) pour ouvrir le navigateur, naviguer et affirmer. Exemple de mise en page :

Spécification specs/example.spec :

# Exemple de spécification

## Ouvrir le site et vérifier le titre

* Ouvrir le navigateur et aller à "https://example.com"
* Le titre de la page doit être "Example Domain"

Étapes step_impl/example.py :

from getgauge.python import step, before_scenario
from selenium import webdriver

driver = None

@before_scenario()
def init_driver():
    global driver
    driver = webdriver.Chrome()

@step("Ouvrir le navigateur et aller à <url>")
def open_url(url):
    driver.get(url)

@step("Le titre de la page doit être <title>")
def check_title(title):
    assert driver.title == title, f"Attendu {title}, obtenu {driver.title}"

Installez Gauge, le runner Python et le plugin Selenium ; exécutez avec gauge run specs/. Pour exécuter sur LambdaTest, définissez le pilote Selenium pour utiliser l’URL distante de LambdaTest et les capacités dans un hook before_scenario au lieu de webdriver.Chrome().

Résumé

Outil Python Rôle Meilleur pour
Playwright Oui Automatisation de navigateur Nouveaux tests E2E, scraping, multi-navigateur, vitesse
Selenium Oui Automatisation de navigateur Tests hérités, écosystème large, nombreux navigateurs
Puppeteer Non Automatisation de navigateur Projets Node.js/Chrome-only
LambdaTest N/A Grille cloud Parallèle, multi-navigateur, Gauge + Selenium
ZenRows Via PW Navigateur de scraping Anti-bot, proxys, CAPTCHA ; utiliser avec Playwright
Gauge Oui Framework de test Spécifications BDD + Selenium (ou autre pilote)

Pour de nouveaux travaux Python, Playwright est le choix par défaut ; ajoutez LambdaTest ou ZenRows lorsque vous avez besoin d’une échelle cloud ou de résilience au scraping. Gardez Selenium pour les ensembles existants et Gauge lorsque vous souhaitez un design de test basé sur les spécifications au-dessus de Selenium.

Liens utiles

Références