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

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

Conteúdo da página

Escolher a pilha correta de automação de navegador em Python afeta a velocidade, a estabilidade e a manutenção. Este resumo compara Playwright vs Selenium vs Puppeteer vs LambdaTest vs ZenRows vs Gauge - com foco em Python, enquanto nota onde o Node.js ou outros idiomas se encaixam.

Playwright trace viewer Aqui temos uma captura de tela do Playwright trace viewer

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 por meio do Chrome DevTools Protocol (CDP) ou WebSocket, então você obtém uma API única para todos os três motores. Ele vem com auto-aguardo: antes de cada ação (clique, preencha, etc.), ele espera pelo elemento para estar visível, estável e ação, o que reduz a fragilidade e a necessidade de sleep ou WebDriverWait manual. A instalação é mínima (pip install playwright depois playwright install), e a API do Python é de primeira classe (síncrona e assíncrona). Use-o para novos conjuntos de testes E2E, scripts ou automação (por exemplo, construindo servidores MCP em Python que controlam um navegador). Para um tutorial completo com exemplos em Python, JavaScript e TypeScript, veja Playwright: Web Scraping & Testing. Combine-o com testes unitários em Python para o resto do seu aplicativo e use Playwright apenas para a camada de navegador. Desvantagens: mais novo que o Selenium, então menos integrações de terceiros e menos material legado; sem suporte oficial para navegadores muito antigos.

Selenium (Python)
O Selenium é o padrão estabelecido para automação de navegador. 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 muitos idiomas (Python, Java, C#, JavaScript, etc.) e a maior gama de navegadores, incluindo os legados. O Selenium 4+ inclui Selenium Manager, então você não precisa mais baixar ou configurar manualmente os binários do driver - o cliente obtém o driver certo para você. A API não aguarda automaticamente; você normalmente usa WebDriverWait e condições esperadas para evitar testes frágeis. Use o Selenium quando você mantém conjuntos existentes de WebDriver, precisa do ecossistema mais amplo e do suporte de linguagem ou deve suportar navegadores mais antigos. Ele se encaixa padrões de design Python para arquitetura limpa quando você envolve o driver em um pequeno adaptador. Desvantagens: geralmente mais lento e mais frágil que o Playwright sem estratégia de aguardo cuidadosa; mais boilerplate.

Puppeteer
O Puppeteer é a biblioteca do Node.js da Google para controlar o Chrome/Chromium sem cabeça (e o Chromium baseado no Edge). Ele usa diretamente o Chrome DevTools Protocol e é a escolha de fato para equipes de JavaScript/TypeScript fazendo automação, geração de PDF ou raspagem no Node. Não há ligação oficial com Python; a API é exclusiva do Node. Se seu stack for Python, use o Playwright (mesma ideia de “controle CDP” com API de primeira classe em Python) ou Selenium. Se você estiver no Node.js e precisar apenas do 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 comercial de teste em nuvem. Você continua escrevendo os mesmos scripts de Selenium ou Playwright (ou Cypress, etc.) localmente, mas em vez de iniciar um navegador local, você se conecta à grade do LambdaTest. Eles fornecem navegadores reais e dispositivos reais (incluindo móveis) na nuvem, então você pode executar testes em paralelo em 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 de múltiplos navegadores, execução em paralelo em larga escala, ou emulação de dispositivos móveis e não quiser hospedar a infraestrutura. Ele também suporta Gauge: você executa seus especificações de Gauge na grade do Selenium do LambdaTest. Desvantagens: pago (com camadas gratuitas); os testes são executados pela rede, então a latência e a disponibilidade dependem de seu serviço.

ZenRows
ZenRows é um serviço comercial de raspagem da web e anti-deteção. Seu Navegador de Raspagem é 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 é executado no lado do ZenRows com proxies residenciais, rotação de IP, bypass de 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 o seu objetivo for a raspagem e você encontrar bloqueios ou limites de taxa; para testes E2E simples no seu próprio aplicativo, o Playwright ou Selenium local é normalmente suficiente. Desvantagens: pago; orientado para a raspagem, não para grades de testes gerais como o LambdaTest.

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

Onde eles executam

  • 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; geralmente Chrome/Chromium na máquina ou em Docker.
  • LambdaTest: Apenas em nuvem; você executa Selenium/Playwright (ou Gauge sobre Selenium) contra sua grade.
  • ZenRows: Navegador de raspagem em nuvem; você o controla a partir de Python (ex: Playwright) ou outras ferramentas compatíveis com CDP.
  • Gauge: Executa em sua máquina ou CI; usa Selenium (ou outro driver) em segundo plano; pode direcionar a grade do LambdaTest.

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

Como usá-los em Python

Playwright (Python)

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

pip install playwright
playwright install

Exemplo síncrono (navegar, clicar, ler texto - o Playwright aguarda automaticamente os 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 (aguardo automático embutido)
    page.get_by_role("link", name="Mais informações...").click()
    heading = page.get_by_role("heading", name="Domínio de Exemplo").text_content()
    print(heading)
    browser.close()

A assíncrona é recomendada para concorrência e se encaixa fluxos de trabalho de saída estruturada com LLM ou scripts que fazem I/O enquanto o navegador está em execução:

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 um folha de dicas 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 automaticamente o driver correto (ChromeDriver, GeckoDriver, etc.), então você não precisa baixar drivers manualmente:

pip install selenium

Exemplo básico com aguardo explícito (o Selenium não aguarda 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 até que o corpo esteja 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, "Mais informações..."))
)
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 suporte oficial para Python)

O Puppeteer é apenas JavaScript/Node.js - a Google não mantém uma API para Python. Se você precisar de uma experiência semelhante ao Puppeteer em Python, use Playwright (mesma ideia de “controle do Chrome sobre CDP”, com Python de primeira classe e aguardo automático). Existe uma portagem não oficial pyppeteer, mas ela não é mantida ativamente; para novos trabalhos em Python, o Playwright é uma melhor escolha. Abaixo está o exemplo em 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 remoto do WebDriver do LambdaTest em vez de um driver local. Defina as capacidades (navegador, OS, nome da construção, 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": "SEU_USUÁRIO_LT",
        "accessKey": "SUA_CHAVE_ACESSO_LT",
        "build": "Playwright-Selenium-Compare",
        "name": "Selenium no LambdaTest",
    }
}
options.set_capability("lt:options", lt_caps["lt:options"])

driver = webdriver.Remote(
    command_executor="https://SEU_USUÁRIO_LT:SUA_CHAVE_ACESSO_LT@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 de CDP para cada execução de teste; você se conecta a ele em vez de iniciar um navegador local. Veja os documentos do LambdaTest para o formato exato da URL de CDP e autenticação:

from playwright.sync_api import sync_playwright

# O LambdaTest fornece um endpoint de CDP por execução; use seus documentos para obter
CDP_URL = "wss://cdp.lambdatest.com/playwright?capabilities=..."  # do painel do 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 Navegador de Raspagem do ZenRows é compatível com CDP, então você usa o connect_over_cdp() do Playwright com sua URL WebSocket. O navegador é executado na nuvem do ZenRows com seus proxies e tratamento anti-bot; seu script permanece o mesmo, exceto por como você se conecta. Apenas o passo de inicialização muda:

from playwright.sync_api import sync_playwright

ZENROWS_WS = "wss://browser.zenrows.com?apikey=SEU_API_KEY_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()

Em seguida, passe o HTML resultante para seu próprio parser ou, por exemplo, conversão de HTML para Markdown com Python para processamento posterior.

Gauge + Selenium (Python)

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

Especificação specs/example.spec:

# Exemplo de especificação

## Abrir site e verificar título

* Abrir navegador e ir para "https://example.com"
* Título da página deve ser "Domínio de Exemplo"

Etapas 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("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 executar no LambdaTest, defina o driver Selenium para usar a URL remota e as capacidades do LambdaTest em um hook before_scenario em vez de webdriver.Chrome().

Resumo

Ferramenta Python Função Melhor para
Playwright Sim Automação de navegador Novos testes E2E, raspagem, 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 Grade em nuvem Paralelo, multi-navegador, Gauge + Selenium
ZenRows Via PW Navegador de raspagem Anti-bot, proxies, CAPTCHA; use com Playwright
Gauge Sim Framework de testes Especificações BDD + Selenium (ou outro driver)

Para novos trabalhos em Python, Playwright é a escolha padrão; adicione LambdaTest ou ZenRows quando precisar de escala em nuvem ou resiliência de raspagem. Mantenha Selenium para conjuntos existentes e Gauge quando quiser um design de testes baseado em especificações sobre o Selenium.

Referências