L'automazione del browser in Python: Playwright, Selenium e altro ancora

Scegliere lo stack giusto per l’automazione del browser in Python influisce sulla velocità, sulla stabilità e sulla manutenzione. Questo riepilogo confronta Playwright vs Selenium vs Puppeteer vs LambdaTest vs ZenRows vs Gauge - con un focus su Python, notando dove Node.js o altri linguaggi si adattano.

Ecco una schermata del Playwright trace viewer

Quando utilizzare quale

Playwright (Python)
Playwright è una libreria open source per l’automazione del browser di Microsoft. Comunica con Chromium, Firefox e WebKit tramite il Chrome DevTools Protocol (CDP) o WebSocket, quindi si ottiene un’unica API per tutti e tre i motori. Viene fornito con auto-waiting: prima di ogni azione (click, compilazione, ecc.) aspetta che l’elemento sia visibile, stabile e azionabile, riducendo la fragilità e la necessità di utilizzare manualmente sleep o WebDriverWait. L’installazione è minimale (pip install playwright quindi playwright install), e l’API Python è di prima classe (sincrona e asincrona). Utilizzalo per nuovi set di test E2E, scripting o automazione (es. costruzione di server MCP in Python che guidano un browser). Per un tutorial completo con esempi in Python, JavaScript e TypeScript, vedi Playwright: Web Scraping & Testing. Combinalo con test unitari in Python per il resto dell’app e utilizza Playwright solo per il livello del browser. Svantaggi: più recente di Selenium, quindi meno integrazioni di terze parti e meno materiali obsoleti; nessun supporto ufficiale per i browser molto vecchi.

Selenium (Python)
Selenium è lo standard consolidato per l’automazione del browser. Il progetto Selenium (open source, sostenuto dalla OpenJS Foundation) fornisce l’API WebDriver: invii comandi a un driver specifico del browser (ChromeDriver, GeckoDriver, ecc.), che comunica con il browser reale. Selenium supporta molti linguaggi (Python, Java, C#, JavaScript, ecc.) e la gamma più ampia di browser, incluso quelli obsoleti. Selenium 4+ include Selenium Manager, quindi non è più necessario scaricare o aggiungere manualmente i binari del driver - il client scarica automaticamente il driver giusto per te. L’API non auto-wait; tipicamente si utilizza WebDriverWait e condizioni attese per evitare test instabili. Utilizza Selenium quando mantieni i set di test WebDriver esistenti, hai bisogno dell’ecosistema più ampio e del supporto linguistico, o devi supportare i browser più vecchi. Si adatta ai pattern di progettazione Python per l’architettura pulita quando si avvolge il driver dietro un piccolo adattatore. Svantaggi: generalmente più lento e più fragile di Playwright senza una strategia di attesa attenta; più codice boilerplate.

Puppeteer
Puppeteer è la libreria Node.js di Google per il controllo di Chrome/Chromium (e Edge basato su Chromium). Utilizza direttamente il Chrome DevTools Protocol e è l’opzione di default per i team JavaScript/TypeScript che fanno automazione solo su Chrome, generazione di PDF o scraping in Node. Non esiste nessuna binding ufficiale per Python; l’API è solo per Node. Se il tuo stack è Python, utilizza Playwright (stessa idea di “controllo CDP” con API Python di prima classe) o Selenium. Se sei in Node.js e hai bisogno solo di Chromium, Puppeteer è un’opzione forte e ben documentata. Svantaggi: solo Chrome/Chromium; nessun Firefox o WebKit; nessun Python.

LambdaTest
LambdaTest è una piattaforma commerciale di test cloud. Continui a scrivere gli stessi script Selenium o Playwright (o Cypress, ecc.) localmente, ma invece di lanciare un browser locale ti connetti alla griglia di LambdaTest. Forniscono browser reali e dispositivi reali (inclusi mobili) in cloud, quindi puoi eseguire test in parallelo su molte combinazioni di OS/browser/versione senza dover gestire il tuo laboratorio. Otterrai un dashboard per i risultati, i video e i log. Utilizzalo quando hai bisogno di copertura cross-browser, esecuzione parallela su larga scala o emulazione mobile e non vuoi ospitare l’infrastruttura. Supporta anche Gauge: esegui i tuoi test Gauge sulla griglia Selenium di LambdaTest. Svantaggi: pagato (con livelli gratuiti); i test vengono eseguiti su rete, quindi latenza e disponibilità dipendono dal loro servizio.

ZenRows
ZenRows è un servizio commerciale di scraping e anti-detection. Il browser di scraping è un browser cloud che controlli tramite Playwright (o altri strumenti compatibili con CDP): connetti il tuo script a un endpoint WebSocket e il browser esegue su ZenRows con proxy residenziali, rotazione IP, bypass anti-bot (es. Cloudflare, DataDome) e gestione opzionale di CAPTCHA. Non devi modificare la logica di Playwright - solo l’endpoint del browser. Utilizzalo quando il tuo obiettivo è lo scraping e incontri blocchi o limiti di velocità; per test E2E normali sul tuo app, il Playwright o Selenium locale è di solito sufficiente. Svantaggi: pagato; mirato allo scraping, non a griglie di test generali come LambdaTest.

Gauge
Gauge è un framework open source per i test di Thoughtworks. Si concentra su specifiche e reporting: scrivi le specifiche in Markdown (o altri formati) con scenari e passaggi, e implementa i passaggi in Python (o Java, JavaScript, ecc.) utilizzando Selenium o qualsiasi altro driver per guidare il browser. Gauge non sostituisce Selenium o Playwright; si posiziona sopra di loro e aggiunge struttura, riutilizzo e report leggibili. Utilizzalo quando desideri specifiche BDD, documentazione vivente e report chiari sopra la tua configurazione esistente di Selenium (o simile). LambdaTest supporta l’esecuzione dei test Gauge sulla loro griglia. Svantaggi: strato extra da imparare e mantenere; devi comunque scegliere e configurare un driver di automazione del browser (es. Selenium).

Dove vengono eseguiti

• Playwright: Locale o CI; Python 3.8+; Windows, macOS, Linux. Funziona anche con browser cloud/remote (es. ZenRows, LambdaTest) collegandosi a un endpoint WebSocket o CDP.
• Selenium: Locale o CI; qualsiasi linguaggio con un client WebDriver; Selenium Grid o un provider come LambdaTest per la scalabilità.
• Puppeteer: Solo Node.js; tipicamente Chrome/Chromium sulla macchina o in Docker.
• LambdaTest: Solo cloud; esegui Selenium/Playwright (o Gauge su Selenium) contro la loro griglia.
• ZenRows: Browser di scraping cloud; lo guidi da Python (es. Playwright) o altri strumenti compatibili con CDP.
• Gauge: Esegue sulla tua macchina o CI; utilizza Selenium (o un altro driver) sotto il cofano; può mirare alla griglia di LambdaTest.

Per un riferimento rapido delle tendenze dell’ecosistema Python, vedi progetti Python più popolari su GitHub; molti strumenti di automazione e test appaiono lì.

Come utilizzarli in Python

Playwright (Python)

Il pacchetto Python di Playwright fornisce sia API sincrone che asincrone. I browser vengono installati separatamente in modo che la libreria rimanga piccola e puoi scegliere solo i motori necessari (Chromium, Firefox, WebKit). Installa e installa i browser:

pip install playwright
playwright install

Esempio sincrono (naviga, clicca, leggi il testo - Playwright auto-wait per gli elementi):

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())
    # Clicca sul link, quindi controlla l'intestazione (built-in auto-wait)
    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’asincrono è consigliato per la concorrenza e si adatta ai flussi di lavoro di output strutturati LLM o script che eseguono I/O mentre il browser è in esecuzione:

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

Per un foglio di riferimento Python e riferimento sintassi, tieni un documento locale a portata di mano.

Selenium (Python)

Il client Python utilizza il protocollo W3C WebDriver. Selenium 4+ utilizza Selenium Manager per scaricare e gestire automaticamente il driver corretto (ChromeDriver, GeckoDriver, ecc.), quindi non è più necessario scaricare manualmente i driver:

pip install selenium

Esempio base con attesa esplicita (Selenium non auto-wait; utilizza WebDriverWait o condizioni attese):

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")
# Attendi che il body sia presente, quindi ottieni il titolo
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "body")))
print(driver.title)
driver.quit()

Clicca e leggi il testo:

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; nessun ufficiale Python)

Puppeteer è solo JavaScript/Node.js - Google non mantiene alcuna API Python. Se hai bisogno di un’esperienza simile a Puppeteer in Python, utilizza Playwright (stessa idea di “controllo Chrome su CDP”, con API Python di prima classe e auto-wait). Esiste un porting non ufficiale pyppeteer, ma non è attivamente mantenuto; per nuovi progetti Python, Playwright è una scelta migliore. Di seguito è l’esempio Node.js per poter confrontare 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)

Utilizzi lo stesso API Selenium; l’unico cambiamento è collegarti al hub di WebDriver remoto di LambdaTest invece di un driver locale. Imposta le capacità (browser, OS, nome build, ecc.) e passa il tuo username e chiave di accesso dal dashboard di 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 può collegarsi a un browser remoto tramite il CDP (Chrome DevTools Protocol). LambdaTest espone un endpoint CDP per ogni esecuzione del test; ti connetti a esso invece di lanciare un browser locale. Vedere i documenti di LambdaTest per il formato esatto dell’URL CDP e l’autenticazione:

from playwright.sync_api import sync_playwright

# LambdaTest fornisce un endpoint CDP per ogni esecuzione; utilizza i loro documenti per ottenerlo
CDP_URL = "wss://cdp.lambdatest.com/playwright?capabilities=..."  # da LT dashboard

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)

Il browser di scraping di ZenRows è compatibile con CDP, quindi utilizza Playwright’s connect_over_cdp() con il loro URL WebSocket. Il browser esegue in cloud ZenRows con i loro proxy e gestione anti-bot; il tuo script rimane lo stesso tranne come ti connetti. Solo il passo di avvio cambia:

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

Poi passa l’HTML risultante al tuo parser o, ad esempio, convertire HTML in Markdown con Python per il processing successivo.

Gauge + Selenium (Python)

Gauge mantiene le specifiche in Markdown (o altri formati) e le implementazioni dei passaggi in Python. Ogni passaggio può richiamare Selenium (o qualsiasi altro driver) per aprire il browser, navigare e affermare. Esempio di layout:

Spec specs/example.spec:

# Esempio di specifica

## Apri il sito e controlla il titolo

* Apri il browser e vai a "https://example.com"
* Il titolo della pagina deve essere "Example Domain"

Passaggi 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("Apri il browser e vai a <url>")
def open_url(url):
    driver.get(url)

@step("Il titolo della pagina deve essere <title>")
def check_title(title):
    assert driver.title == title, f"Atteso {title}, ottenuto {driver.title}"

Installa Gauge, il runner Python e il plugin Selenium; esegui con gauge run specs/. Per eseguirlo su LambdaTest, imposta il driver Selenium per utilizzare l’URL remoto e le capacità di LambdaTest in un hook before_scenario invece di webdriver.Chrome().

Riepilogo

Per nuovi progetti Python, Playwright è la scelta predefinita; aggiungi LambdaTest o ZenRows quando hai bisogno di scalabilità cloud o resilienza allo scraping. Mantieni Selenium per i set di test esistenti e Gauge quando desideri un design delle specifiche iniziale sopra Selenium.

Link utili

• Playwright: Web Scraping & Testing
• Top 17 Trending Python Projects on GitHub
• Unit Testing in Python
• Python Design Patterns for Clean Architecture
• Python Cheatsheet
• LLMs Structured Output: Ollama, Qwen3 & Python or Go
• Convertire HTML in Markdown con Python: Una Guida Completa
• Costruire server MCP in Python: Ricerca Web e Scraping

Riferimenti

• Playwright Python – Installazione e introduzione
• Selenium 4.31 release (2025)
• Puppeteer vs Playwright vs Selenium (2026)
• Selenium vs Playwright vs Puppeteer benchmark
• Playwright vs Selenium – BrowserStack
• ZenRows – Integra Playwright con ZenRows
• ZenRows Scraping Browser – Iniziare con Playwright
• LambdaTest – Selenium con Gauge