Automatización de Navegadores en Python: Playwright, Selenium y Más

Automatización de navegador en Python y pruebas E2E comparadas.

Índice

Elegir el stack correcto para la automatización del navegador en Python afecta la velocidad, la estabilidad y el mantenimiento. Este resumen compara Playwright vs Selenium vs Puppeteer vs LambdaTest vs ZenRows vs Gauge - con enfoque en Python, mientras se señala donde encajan Node.js u otros lenguajes.

Playwright trace viewer Aquí tenemos una captura de pantalla de Playwright trace viewer

Cuándo usar cada uno

Playwright (Python)
Playwright es una biblioteca de automatización del navegador de código abierto de Microsoft. Habla con Chromium, Firefox y WebKit a través del Chrome DevTools Protocol (CDP) o WebSocket, por lo que obtienes una API única para los tres motores. Viene con auto-espere: antes de cada acción (hacer clic, rellenar, etc.), espera a que el elemento sea visible, estable y accionable, lo que reduce la fragilidad y la necesidad de sleep o WebDriverWait manual. La instalación es mínima (pip install playwright luego playwright install), y la API de Python es de primera clase (sincrónica y asíncrona). Úsalo para nuevos conjuntos de pruebas E2E, scripting o automatización (por ejemplo, construir servidores MCP en Python que manejan un navegador). Para una guía completa con ejemplos en Python, JavaScript y TypeScript, consulta Playwright: Web Scraping & Testing. Combínalo con pruebas unitarias en Python para el resto de tu aplicación y usa Playwright solo para la capa del navegador. Inconvenientes: más reciente que Selenium, por lo tanto, menos integraciones de terceros y menos material legado; sin soporte oficial para navegadores muy antiguos.

Selenium (Python)
Selenium es el estándar consolidado para la automatización del navegador. El Proyecto Selenium (de código abierto, respaldado por la OpenJS Foundation) proporciona la API WebDriver: envías comandos a un controlador específico del navegador (ChromeDriver, GeckoDriver, etc.), que habla con el navegador real. Selenium admite muchos lenguajes (Python, Java, C#, JavaScript, etc.) y el rango más amplio de navegadores, incluyendo los legados. Selenium 4+ incluye Selenium Manager, por lo que ya no necesitas descargar o configurar manualmente los archivos de los controladores; el cliente obtiene el controlador correcto para ti. La API no espera automáticamente; normalmente usas WebDriverWait y condiciones esperadas para evitar pruebas frágiles. Usa Selenium cuando mantengas suites existentes de WebDriver, necesites el ecosistema más amplio y el soporte de idiomas, o debas soportar navegadores antiguos. Encaja patrones de diseño de Python para arquitectura limpia cuando envuelvas el controlador detrás de un pequeño adaptador. Inconvenientes: generalmente más lento y más frágil que Playwright sin una estrategia de espera cuidadosa; más código de relleno.

Puppeteer
Puppeteer es la biblioteca de Node.js de Google para controlar Chrome/Chromium (y Edge basado en Chromium). Usa directamente el Chrome DevTools Protocol y es la opción por defecto para equipos de JavaScript/TypeScript que realizan automatización solo en Chrome, generación de PDF o scraping en Node. No hay vinculo oficial para Python; la API es solo para Node. Si tu stack es Python, usa Playwright (misma idea de “control CDP” con API de primera clase para Python) o Selenium. Si estás en Node.js y solo necesitas Chromium, Puppeteer es una opción sólida y bien documentada. Inconvenientes: solo Chrome/Chromium; no Firefox ni WebKit; no Python.

LambdaTest
LambdaTest es una plataforma comercial de prueba en la nube. Mantienes escribiendo los mismos scripts de Selenium o Playwright (o Cypress, etc.) localmente, pero en lugar de lanzar un navegador local te conectas a la red de LambdaTest. Proporcionan navegadores reales y dispositivos reales (incluyendo móviles) en la nube, por lo que puedes ejecutar pruebas en paralelo en muchas combinaciones de OS/navegador/versión sin mantener tu propio laboratorio. Obtienes un panel para resultados, videos y logs. Úsalo cuando necesites cobertura multi-navegador, ejecución en paralelo a gran escala o emulación móvil y no quieras alojar la infraestructura. También soporta Gauge: ejecutas tus especificaciones de Gauge en su red de Selenium. Inconvenientes: pagado (con niveles gratuitos); las pruebas se ejecutan a través de la red, por lo que la latencia y disponibilidad dependen de su servicio.

ZenRows
ZenRows es un servicio comercial de scraping y detección anti-bot. Su Navegador de Scraping es un navegador en la nube que controlas mediante Playwright (u otras herramientas compatibles con CDP): conectas tu script a un punto final de WebSocket y el navegador se ejecuta en el lado de ZenRows con proxies residenciales, rotación de IP, bypass de bot (ej. Cloudflare, DataDome) y manejo opcional de CAPTCHA. No cambias tu lógica de Playwright, solo el punto final del navegador. Úsalo cuando tu objetivo sea scraping y te encuentres con bloqueos o límites de tasa; para pruebas E2E normales en tu propia aplicación, Playwright o Selenium local suelen ser suficientes. Inconvenientes: pagado; enfocado en scraping, no en cuadrículas de prueba generales como LambdaTest.

Gauge
Gauge es un framework de prueba de código abierto de Thoughtworks. Se centra en especificaciones y reportes: escribes especificaciones en Markdown (u otros formatos) con escenarios y pasos, e implementas los pasos en Python (o Java, JavaScript, etc.) usando Selenium u otro controlador para manejar el navegador. Gauge no reemplaza a Selenium ni a Playwright; se sitúa encima de ellos y agrega estructura, reutilización y reportes legibles. Úsalo cuando desees especificaciones de estilo BDD, documentación viva y reportes claros sobre tu configuración existente de Selenium (o similar). LambdaTest soporta ejecutar pruebas de Gauge en su cuadrícula. Inconvenientes: capa adicional para aprender y mantener; aún necesitas elegir y configurar un controlador de automatización del navegador (ej. Selenium).

Donde se ejecutan

  • Playwright: Local o CI; Python 3.8+; Windows, macOS, Linux. También funciona con navegadores en la nube/remotos (ej. ZenRows, LambdaTest) conectándose a un endpoint de WebSocket o CDP.
  • Selenium: Local o CI; cualquier lenguaje con un cliente WebDriver; Selenium Grid o un proveedor como LambdaTest para escalar.
  • Puppeteer: Solo Node.js; normalmente Chrome/Chromium en la máquina o en Docker.
  • LambdaTest: Solo en la nube; ejecutas Selenium/Playwright (o Gauge sobre Selenium) contra su cuadrícula.
  • ZenRows: Navegador de scraping en la nube; lo controlas desde Python (ej. Playwright) u otras herramientas compatibles con CDP.
  • Gauge: Ejecuta en tu máquina o en CI; usa Selenium (u otro controlador) detrás; puede apuntar a la cuadrícula de LambdaTest.

Para una referencia rápida de tendencias en el ecosistema de Python, consulta proyectos de Python más populares en GitHub; muchos herramientas de automatización y pruebas aparecen allí.

Cómo usarlos en Python

Playwright (Python)

El paquete de Python de Playwright proporciona tanto APIs sincrónicas como asíncronas. Los navegadores se instalan por separado para que la biblioteca permanezca pequeña y puedas elegir solo los motores que necesitas (Chromium, Firefox, WebKit). Instala e instala los navegadores:

pip install playwright
playwright install

Ejemplo sincrónico (navegar, hacer clic, leer texto-Playwright auto-espere elementos):

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())
    # Hacer clic en el enlace, luego verificar encabezado (auto-espere incluido)
    page.get_by_role("link", name="Más información...").click()
    heading = page.get_by_role("heading", name="Ejemplo de dominio").text_content()
    print(heading)
    browser.close()

Se recomienda la versión asíncrona para concurrencia y encaja flujos de trabajo de salida estructurada de LLM o scripts que realicen I/O mientras el navegador se ejecuta:

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

Para una hoja de trucos de Python y referencia de sintaxis, mantén un documento local a mano.

Selenium (Python)

El cliente de Python usa el protocolo W3C WebDriver. Selenium 4+ usa Selenium Manager para descargar y gestionar automáticamente el controlador correcto (ChromeDriver, GeckoDriver, etc.), por lo que ya no necesitas descargar controladores manualmente:

pip install selenium

Ejemplo básico con espera explícita (Selenium no espera automáticamente; usa WebDriverWait o condiciones esperadas):

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")
# Espera a que el cuerpo esté presente, luego obtén el título
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "body")))
print(driver.title)
driver.quit()

Hacer clic y leer texto:

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, "Más información..."))
)
link.click()
heading = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.CSS_SELECTOR, "h1"))
)
print(heading.text)
driver.quit()

Puppeteer (Node.js; no oficial para Python)

Puppeteer es solo JavaScript/Node.js-Google no mantiene una API para Python. Si necesitas una experiencia similar a Puppeteer en Python, usa Playwright (misma idea de “controlar Chrome sobre CDP”, con API de primera clase para Python y auto-espere). Existe un puerto no oficial pyppeteer, pero no se mantiene activamente; para nuevos trabajos en Python, Playwright es una mejor opción. El ejemplo siguiente es para Node.js para que lo compares con la 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)

Usas la misma API de Selenium; el único cambio es conectarte al hub de WebDriver remoto de LambdaTest en lugar de un controlador local. Establece las capacidades (navegador, OS, nombre de construcción, etc.) y pasa tu nombre de usuario y clave de acceso desde el panel de LambdaTest:

from selenium import webdriver

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

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

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

LambdaTest (Python: Playwright)

Playwright puede conectarse a un navegador remoto mediante el CDP (Chrome DevTools Protocol). LambdaTest expone un punto final de CDP para cada ejecución de prueba; te conectas a él en lugar de lanzar un navegador local. Consulta la documentación de LambdaTest para el formato exacto de la URL de CDP y la autenticación:

from playwright.sync_api import sync_playwright

# LambdaTest proporciona un punto final de CDP por ejecución; usa su documentación para obtenerlo
CDP_URL = "wss://cdp.lambdatest.com/playwright?capabilities=..."  # desde el panel de 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)

El Navegador de Scraping de ZenRows es compatible con CDP, por lo que usas connect_over_cdp() de Playwright con su URL de WebSocket. El navegador se ejecuta en la nube de ZenRows con sus proxies y manejo anti-bot; tu script permanece igual excepto por cómo te conectas. Solo cambia el paso de lanzamiento:

from playwright.sync_api import sync_playwright

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

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

Luego pasa el HTML resultante a tu propio analizador o, por ejemplo, convierte HTML a Markdown con Python para procesamiento posterior.

Gauge + Selenium (Python)

Gauge mantiene las especificaciones en Markdown (u otros formatos) y las implementaciones de pasos en Python. Cada paso puede llamar a Selenium (u otro controlador) para abrir el navegador, navegar y afirmar. Ejemplo de diseño:

Especificación specs/example.spec:

# Ejemplo de especificación

## Abrir sitio y verificar título

* Abrir navegador y navegar a "https://example.com"
* El título de la página debe ser "Ejemplo de dominio"

Pasos 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("Abrir navegador y navegar a <url>")
def open_url(url):
    driver.get(url)

@step("El título de la página debe ser <title>")
def check_title(title):
    assert driver.title == title, f"Se esperaba {title}, se obtuvo {driver.title}"

Instala Gauge, el ejecutable de Python y el plugin de Selenium; ejecútalo con gauge run specs/. Para ejecutar en LambdaTest, establece el controlador de Selenium para usar la URL remota de LambdaTest y las capacidades en una función before_scenario en lugar de webdriver.Chrome().

Resumen

Herramienta Python Rol Mejor para
Playwright Sí Automatización del navegador Pruebas E2E nuevas, scraping, multi-navegador, velocidad
Selenium Sí Automatización del navegador Pruebas legadas, ecosistema más amplio, muchos navegadores
Puppeteer No Automatización del navegador Proyectos en Node.js/Chrome solo
LambdaTest N/A Cuadrícula en la nube Ejecución en paralelo, multi-navegador, Gauge + Selenium
ZenRows Vía PW Navegador de scraping Anti-bot, proxies, CAPTCHA; usar con Playwright
Gauge Sí Framework de prueba Especificaciones BDD + Selenium (u otro controlador)

Para nuevos trabajos en Python, Playwright es la opción por defecto; agrega LambdaTest o ZenRows cuando necesites escala en la nube o resiliencia en scraping. Mantén Selenium para suites existentes y Gauge cuando desees un diseño de prueba basado en especificaciones sobre Selenium.

Enlaces útiles

Referencias