Automação de Navegadores em Python: Playwright, Selenium e Mais

Automação de navegador com Python e testes E2E comparados.

Conteúdo da página

A escolha da stack de automação de navegador correta em Python afeta a velocidade, estabilidade e manutenção. Esta visão geral compara Playwright vs Selenium vs Puppeteer vs LambdaTest vs ZenRows vs Gauge - com foco em Python, embora observando onde Node.js ou outras linguagens se encaixam.

Visualizador de rastreamento do Playwright Aqui temos uma captura de tela do visualizador de rastreamento do Playwright

Quando usar qual

Playwright (Python)
O Playwright é uma biblioteca de automação de navegador de código aberto da Microsoft. Ele se comunica com Chromium, Firefox e WebKit via Chrome DevTools Protocol (CDP) ou WebSocket, proporcionando uma única API para os três motores. Ele vem com espera automática (auto-waiting): antes de cada ação (clique, preenchimento, etc.), ele espera que o elemento esteja visível, estável e acionável, o que reduz a instabilidade e a necessidade de sleep manual ou WebDriverWait. A configuração é mínima (pip install playwright e depois playwright install), e a API em Python é de primeira classe (síncrona e assíncrona). Use-o para novas suítes de testes E2E, scripts ou automação (ex. construindo servidores MCP em Python que acionam um navegador). Para um guia completo com exemplos em Python, JavaScript e TypeScript, consulte Playwright: Web Scraping & Testing. Combine-o com testes unitários em Python para o resto do seu aplicativo e use o Playwright apenas para a camada do navegador. Desvantagens: mais novo que o Selenium, portanto, possui menos integrações de terceiros e menos material legado; sem suporte oficial para navegadores muito antigos.

Selenium (Python)
O Selenium é o padrão de longa data para automação de navegadores. O Projeto Selenium (código aberto, apoiado pela OpenJS Foundation) fornece a API WebDriver: você envia comandos para um driver específico do navegador (ChromeDriver, GeckoDriver, etc.), que se comunica com o navegador real. O Selenium suporta muitas linguagens (Python, Java, C#, JavaScript, etc.) e a maior gama de navegadores, incluindo os legados. O Selenium 4+ inclui o Selenium Manager, então você não precisa mais baixar ou configurar binaries de drivers manualmente - o cliente busca o driver certo para você. A API não possui espera automática; normalmente você usa WebDriverWait e condições esperadas para evitar testes instáveis. Use o Selenium quando manter suítes WebDriver existentes, precisar do ecossistema e suporte a linguagens mais amplos, ou precisar suportar navegadores mais antigos. Ele se encaixa em padrões de design Python para arquitetura limpa quando você encapsula o driver atrás de um adaptador pequeno. Desvantagens: geralmente mais lento e mais frágil que o Playwright sem uma estratégia de espera cuidadosa; mais boilerplate.

Puppeteer
O Puppeteer é a biblioteca Node.js do Google para controlar Chrome/Chromium headless (e Edge baseado em Chromium). Ele usa o Chrome DevTools Protocol diretamente e é a escolha de facto para equipes JavaScript/TypeScript fazendo automação apenas com Chrome, geração de PDF ou scraping em Node. Não há binding oficial em Python; a API é apenas para Node. Se sua stack é Python, use o Playwright (mesma ideia de “controle CDP” com Python de primeira classe) ou Selenium. Se você estiver em Node.js e precisar apenas de Chromium, o Puppeteer é uma opção forte e bem documentada. Desvantagens: apenas Chrome/Chromium; sem Firefox ou WebKit; sem Python.

LambdaTest
O LambdaTest é uma plataforma de teste em nuvem comercial. Você continua escrevendo os mesmos scripts Selenium ou Playwright (ou Cypress, etc.) localmente, mas em vez de iniciar um navegador local, você se conecta à grid do LambdaTest. Eles fornecem navegadores reais e dispositivos reais (incluindo mobile) na nuvem, para que você possa executar testes em paralelo através de muitas combinações de OS/navegador/versão sem manter seu próprio laboratório. Você obtém um painel para resultados, vídeos e logs. Use-o quando precisar de cobertura cross-browser, execução paralela em escala ou emulação mobile e não quiser hospedar a infraestrutura. Ele também suporta Gauge: você executa suas specs do Gauge na grid Selenium deles. Desvantagens: pago (com níveis gratuitos); os testes rodam pela rede, então latência e disponibilidade dependem do serviço deles.

ZenRows
O ZenRows é um serviço comercial de web scraping e anti-detecção. Seu Scraping Browser é um navegador em nuvem que você controla via Playwright (ou outras ferramentas compatíveis com CDP): você conecta seu script a um endpoint WebSocket e o navegador roda no lado do ZenRows com proxies residenciais, rotação de IP, bypass anti-bot (ex. Cloudflare, DataDome) e tratamento opcional de CAPTCHA. Você não muda sua lógica do Playwright - apenas o endpoint do navegador. Use-o quando seu objetivo for scraping e você encontrar bloqueios ou limites de taxa; para testes E2E simples no seu próprio aplicativo, o Playwright ou Selenium local geralmente é suficiente. Desvantagens: pago; voltado para scraping, não para grids de teste de propósito geral como o LambdaTest.

Gauge
O Gauge é um framework de teste de código aberto da Thoughtworks. Ele se concentra em especificações e relatórios: você escreve specs em Markdown (ou outros formatos) com cenários e passos, e implementa os passos em Python (ou Java, JavaScript, etc.) usando Selenium - ou qualquer outro driver - para acionar o navegador. O Gauge não substitui o Selenium ou o Playwright; ele fica sobre eles e adiciona estrutura, reutilização e relatórios legíveis. Use-o quando quiser specs no estilo BDD, documentação viva e relatórios de teste claros sobre sua configuração existente do Selenium (ou similar). O LambdaTest suporta a execução de testes do Gauge na grid deles. Desvantagens: camada extra para aprender e manter; você ainda precisa escolher e configurar um driver de automação de navegador (ex. Selenium).

Onde eles rodam

  • Playwright: Local ou CI; Python 3.8+; Windows, macOS, Linux. Também funciona com navegadores em nuvem/remotos (ex. ZenRows, LambdaTest) conectando-se a um endpoint WebSocket ou CDP.
  • Selenium: Local ou CI; qualquer linguagem com um cliente WebDriver; Selenium Grid ou um provedor como LambdaTest para escala.
  • Puppeteer: Apenas Node.js; tipicamente Chrome/Chromium na máquina ou em Docker.
  • LambdaTest: Apenas nuvem; você executa Selenium/Playwright (ou Gauge sobre Selenium) contra a grid deles.
  • ZenRows: Scraping Browser em nuvem; você o aciona do Python (ex. Playwright) ou outras ferramentas compatíveis com CDP.
  • Gauge: Roda na sua máquina ou CI; usa Selenium (ou outro driver) por baixo dos panos; pode mirar na grid do LambdaTest.

Para uma referência rápida de tendências do ecossistema Python, consulte projetos Python mais populares no GitHub; muitas ferramentas de automação e teste aparecem lá.

Como usá-los em Python

Playwright (Python)

O pacote Python do Playwright fornece APIs síncronas e assíncronas. Os navegadores são instalados separadamente para que a biblioteca permaneça pequena e você possa escolher apenas os motores necessários (Chromium, Firefox, WebKit). Instale e instale os navegadores:

pip install playwright
playwright install

Exemplo síncrono (navegar, clicar, ler texto - o Playwright espera automaticamente pelos 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())
    # Clique no link, depois verifique o título (espera automática embutida)
    page.get_by_role("link", name="More information...").click()
    heading = page.get_by_role("heading", name="Example Domain").text_content()
    print(heading)
    browser.close()

O assíncrono é recomendado para concorrência e se encaixa em fluxos de trabalho de saída estruturada LLM ou scripts que fazem E/S enquanto o navegador roda:

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 uma lista de atalhos do Python e referência de sintaxe, mantenha um documento local à mão.

Selenium (Python)

O cliente Python usa o protocolo W3C WebDriver. O Selenium 4+ usa o Selenium Manager para baixar e gerenciar o driver correto (ChromeDriver, GeckoDriver, etc.) automaticamente, então você não precisa mais baixar drivers manualmente:

pip install selenium

Exemplo básico com espera explícita (o Selenium não espera automaticamente; use WebDriverWait ou condições 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")
# Aguarde o corpo estar presente, depois obtenha o título
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "body")))
print(driver.title)
driver.quit()

Clique e leia o 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, "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; sem Python oficial)

O Puppeteer é apenas JavaScript/Node.js - o Google não mantém uma API Python. Se você precisar de uma experiência similar ao Puppeteer em Python, use o Playwright (mesma ideia de “controle Chrome via CDP”, com Python de primeira classe e esperas automáticas). Existe um port não oficial pyppeteer, mas não é mantido ativamente; para novos trabalhos em Python, o Playwright é a melhor escolha. Abaixo está o exemplo Node.js para que você possa comparar a 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)

Você usa a mesma API do Selenium; a única mudança é conectar-se ao hub WebDriver remoto do LambdaTest em vez de um driver local. Defina capacidades (navegador, OS, nome da build, etc.) e passe seu nome de usuário e chave de acesso do painel do 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)

O Playwright pode se conectar a um navegador remoto via CDP (Chrome DevTools Protocol). O LambdaTest expõe um endpoint CDP para cada execução de teste; você se conecta a ele em vez de iniciar um navegador local. Consulte a documentação do LambdaTest para o formato exato da URL CDP e autenticação:

from playwright.sync_api import sync_playwright

# O LambdaTest fornece um endpoint CDP por execução; use sua documentação para obtê-lo
CDP_URL = "wss://cdp.lambdatest.com/playwright?capabilities=..."  # do painel 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)

O Scraping Browser do ZenRows é compatível com CDP, então você usa connect_over_cdp() do Playwright com a URL WebSocket deles. O navegador roda na nuvem do ZenRows com seus proxies e tratamento anti-bot; seu script permanece o mesmo, exceto por como você se conecta. Apenas a etapa de lançamento muda:

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

Então, passe o HTML resultante para o seu próprio parser ou, por exemplo, convertendo HTML para Markdown com Python para processamento subsequente.

Gauge + Selenium (Python)

O Gauge mantém specs em Markdown (ou outros formatos) e implementações de passos em Python. Cada passo pode chamar o Selenium (ou qualquer outro driver) para abrir o navegador, navegar e afirmar. Exemplo de layout:

Spec specs/example.spec:

# Exemplo de spec

## Abrir site e verificar título

* Abrir navegador e ir para "https://example.com"
* O título da página deve ser "Example Domain"

Passos 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 e ir para <url>")
def open_url(url):
    driver.get(url)

@step("O título da página deve ser <title>")
def check_title(title):
    assert driver.title == title, f"Esperado {title}, obtido {driver.title}"

Instale o Gauge, o runner Python e o plugin Selenium; execute com gauge run specs/. Para rodar no LambdaTest, defina o driver Selenium para usar a URL remota e capacidades do LambdaTest em um hook before_scenario em vez de webdriver.Chrome().

Resumo

Ferramenta Python Papel Melhor para
Playwright Sim Automação de navegador Novos testes E2E, scraping, multi-navegador, velocidade
Selenium Sim Automação de navegador Testes legados, ecossistema amplo, muitos navegadores
Puppeteer Não Automação de navegador Projetos Node.js/Chrome-only
LambdaTest N/A Grid em nuvem Paralelo, cross-browser, Gauge + Selenium
ZenRows Via PW Scraping browser Anti-bot, proxies, CAPTCHA; use com Playwright
Gauge Sim Framework de teste Specs BDD + Selenium (ou outro driver)

Para novos trabalhos em Python, o Playwright é a escolha padrão; adicione LambdaTest ou ZenRows quando precisar de escala em nuvem ou resiliência de scraping. Mantenha o Selenium para suítes existentes e Gauge quando quiser design de teste baseado em specs sobre o Selenium.

Referências

Assinar

Receba novos artigos sobre sistemas, infraestrutura e engenharia de IA.