Automação de Navegadores em Go: Selenium, chromedp, Playwright, ZenRows

A escolha da pilha de automação de navegador e raspagem web em Go [{< ref “.” >} “browser automation stack and webscraping in Go”) afeta a velocidade, a manutenção e onde seu código é executado.

Esta visão geral compara chromedp, Playwright for Go, Selenium (cliente Go) e ZenRows com exemplos de código em Go para cada um, para que você possa escolher o melhor ajuste para raspagem, testes E2E ou automação agendada.

TL;DR - Comparação rápida

Quando usar cada um

chromedp - Biblioteca Go idiomática que controla Chrome/Chromium via Chrome DevTools Protocol (CDP). Sem WebDriver ou servidor Selenium; sem runtime externo. Ideal para raspagem e automação leve quando apenas Chrome é aceitável. A principal diferença em relação ao Playwright for Go é que o chromedp é Go puro e exclusivo para Chrome, enquanto o Playwright suporta múltiplos navegadores e requer a instalação de binários de navegador.

Playwright for Go - Bindings em Go mantidos pela comunidade para Microsoft Playwright. Uma única API para Chromium, Firefox e WebKit; espera automática por elementos; seletores e recursos modernos. Use quando precisar de testes E2E multi-navegador ou uma API focada em testes e estiver bem com uma etapa extra de instalação para os navegadores.

Selenium (Go) - A abordagem clássica do WebDriver: um cliente Go se comunica com um driver de navegador (ChromeDriver, GeckoDriver, etc.). O Selenium suporta Go; você executa um processo de driver ou se conecta a um grid. Use para suítes legadas ou quando precisar do ecossistema mais amplo; para novos projetos Go, chromedp ou Playwright for Go geralmente simplificam a configuração.

ZenRows - Não é uma biblioteca de driver, mas uma API de Raspagem (e um Navegador de Raspagem opcional) que você chama do Go via HTTP. O ZenRows gerencia navegadores headless, renderização de JS, proxies residenciais, bypass anti-bot e CAPTCHA. Use quando seu objetivo for raspagem e você encontrar bloqueios ou limites de taxa; para testes E2E locais, chromedp ou Playwright geralmente são suficientes.

Para uma referência rápida de ferramentas Go e estrutura, veja Go Project Structure: Practices & Patterns; manter a automação em um pacote dedicado se encaixa bem com internal/ ou pkg/.

chromedp: Go puro, exclusivo para Chrome

O chromedp não requer binários de terceiros: implementa o CDP em Go e inicia (ou se conecta ao) Chrome/Chromium. Instalação:

go get -u github.com/chromedp/chromedp

Exemplo: navegar, ler título e extrair texto por seletor. Todas as ações rodam dentro de chromedp.Run; use chromedp.ByQuery para seletores CSS.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/chromedp/chromedp"
)

func main() {
	ctx, cancel := chromedp.NewContext(context.Background())
	defer cancel()

	var title string
	var bodyText string
	err := chromedp.Run(ctx,
		chromedp.Navigate("https://example.com"),
		chromedp.Title(&title),
		chromedp.Text("h1", &bodyText, chromedp.ByQuery),
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Title:", title)
	fmt.Println("Heading:", bodyText)
}

Exemplo: clicar e ler HTML atualizado. Use chromedp.Click e chromedp.OuterHTML (ou chromedp.InnerHTML) com chromedp.ByQuery. Substitua targetURL pela sua página (ex. um servidor de teste ou qualquer URL):

	targetURL := "https://example.com"
	var outerBefore, outerAfter string
	err := chromedp.Run(ctx,
		chromedp.Navigate(targetURL),
		chromedp.OuterHTML("#content", &outerBefore, chromedp.ByQuery),
		chromedp.Click("#content", chromedp.ByQuery),
		chromedp.OuterHTML("#content", &outerAfter, chromedp.ByQuery),
	)

Por padrão, o Chrome roda headless. Para mostrar uma janela ou alterar flags, use um alocador personalizado (veja o chromedp ExecAllocator example). Para Docker ou CI, a imagem chromedp/headless-shell fornece uma build menor do Chrome headless que o chromedp pode usar direto da caixa - assim você pode rodar chromedp em ambientes headless sem instalar o Chrome no host.

Mais exemplos (capturas de tela, PDFs, formulários, cookies) estão no repositório chromedp/examples.

Playwright for Go: multi-navegador, espera automática

O Playwright for Go oferece os mesmos recursos multi-navegador e de espera automática que o Playwright em outras linguagens. Instale a biblioteca e depois os binários do navegador:

go get -u github.com/playwright-community/playwright-go
go run github.com/playwright-community/playwright-go/cmd/playwright@latest install --with-deps

Exemplo: iniciar Chromium, abrir uma página, tirar uma captura de tela. Você pode usar pw.Firefox ou pw.WebKit para outros motores.

package main

import (
	"log"

	"github.com/playwright-community/playwright-go"
)

func main() {
	pw, err := playwright.Run()
	if err != nil {
		log.Fatalf("could not launch playwright: %v", err)
	}
	defer pw.Stop()

	browser, err := pw.Chromium.Launch(playwright.BrowserTypeLaunchOptions{Headless: playwright.Bool(true)})
	if err != nil {
		log.Fatalf("could not launch Chromium: %v", err)
	}
	defer browser.Close()

	page, err := browser.NewPage()
	if err != nil {
		log.Fatalf("could not create page: %v", err)
	}

	_, err = page.Goto("https://example.com")
	if err != nil {
		log.Fatalf("could not goto: %v", err)
	}

	_, err = page.Screenshot(playwright.PageScreenshotOptions{Path: playwright.String("example.png")})
	if err != nil {
		log.Fatalf("could not screenshot: %v", err)
	}
}

Exemplo: preencher um formulário e obter texto. O Playwait espera automaticamente pelos elementos se tornarem acionáveis, o que reduz a instabilidade em comparação com CDP puro ou Selenium sem esperas explícitas.

	page.Goto("https://example.com/login")
	page.Locator("#username").Fill("user")
	page.Locator("#password").Fill("secret")
	page.Locator("button[type=submit]").Click()
	content, _ := page.Locator("h1").TextContent()
	fmt.Println(content)

Você pode usar o Playwright for Go para raspagem web e para testes: navegar, clicar, extrair HTML ou texto e, opcionalmente, controlar o Navegador de Raspagem do ZenRows via seu endpoint compatível com CDP/Playwright quando precisar de bypass anti-bot ou proxies.

Selenium (cliente Go)

A API WebDriver do Selenium está disponível em Go via clientes da comunidade (ex. tebeka/selenium). Você executa um driver de navegador (ChromeDriver, GeckoDriver) ou se conecta a um grid; o código Go envia comandos WebDriver. Então sim, o Selenium suporta Go - você só precisa gerenciar o processo do driver ou usar um grid na nuvem.

Exemplo: conectar ao ChromeDriver, navegar, obter título. O driver deve estar em execução (ex. chromedriver --port=4444 ou Selenium Manager no Selenium 4).

package main

import (
	"fmt"
	"log"

	"github.com/tebeka/selenium"
)

func main() {
	caps := selenium.Capabilities{"browserName": "chrome"}
	wd, err := selenium.NewRemote(caps, "http://localhost:4444/wd/hub")
	if err != nil {
		log.Fatal(err)
	}
	defer wd.Quit()

	err = wd.Get("https://example.com")
	if err != nil {
		log.Fatal(err)
	}
	title, err := wd.Title()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Title:", title)
}

Para novos projetos Go, chromedp (sem driver) ou Playwright for Go (multi-navegador, espera automática) são geralmente mais fáceis; use Selenium quando já tiver suítes WebDriver ou precisar de um grid específico.

ZenRows: API de Raspagem do Go

O ZenRows expõe uma API de Raspagem (HTTP) e um Navegador de Raspagem opcional (compatível com CDP/Playwright). Do Go você geralmente usa a API de Raspagem: envie um GET (ou POST) com a URL alvo e opções; o ZenRows retorna o HTML renderizado ou outros formatos. Sem navegador local para gerenciar. Use o ZenRows quando a raspagem for o objetivo e você precisar de proxies, bypass anti-bot ou tratamento de CAPTCHA; para automação local simples, chromedp ou Playwright são suficientes.

Instale o SDK oficial do Go:

go get github.com/zenrows/zenrows-go-sdk/service/api

Exemplo: GET simples com a API de Raspagem do ZenRows. Defina sua chave de API via cliente ou variável de ambiente ZENROWS_API_KEY.

package main

import (
	"context"
	"fmt"
	"log"

	scraperapi "github.com/zenrows/zenrows-go-sdk/service/api"
)

func main() {
	client := scraperapi.NewClient(
		scraperapi.WithAPIKey("YOUR_API_KEY"),
	)

	response, err := client.Get(context.Background(), "https://example.com", nil)
	if err != nil {
		log.Fatal(err)
	}
	if err := response.Error(); err != nil {
		log.Fatal(err)
	}
	fmt.Println("Body length:", len(response.Body()))
	fmt.Println("Status:", response.Status())
}

Exemplo: renderização JS e proxies premium. Personalize o comportamento com RequestParameters:

	params := &scraperapi.RequestParameters{
		JSRender:          true,
		UsePremiumProxies:  true,
		ProxyCountry:       "US",
	}
	response, err := client.Get(context.Background(), "https://example.com", params)
	if err != nil {
		log.Fatal(err)
	}
	if err := response.Error(); err != nil {
		log.Fatal(err)
	}
	html := response.String()

O SDK suporta limites de concorrência (WithMaxConcurrentRequests), tentativas (WithMaxRetryCount, WithRetryWaitTime) e outras opções; veja a documentação do ZenRows Scraper API Go SDK.

Resumo

• chromedp: Go puro, CDP, exclusivo para Chrome; sem driver. Use para automação e raspagem rápidas e de baixo overhead. Execute no Docker com chromedp/headless-shell se necessário.
• Playwright for Go: Multi-navegador, espera automática, amigável para testes. Use para testes E2E ou quando quiser uma única API para Chromium, Firefox e WebKit; também é bom para raspagem.
• Selenium (Go): WebDriver do Go; driver ou grid necessário. Use ao manter suítes Selenium existentes ou quando precisar de um grid específico.
• ZenRows: API de Raspagem (e Navegador de Raspagem) do Go. Use quando a raspagem for o foco e você precisar de resiliência contra bloqueios, limites de taxa e anti-bot.

Para mais práticas Go - linters, layout de projetos e injeção de dependências - veja Go Linters: Essential Tools for Code Quality, Dependency Injection in Go: Patterns & Best Practices, e o Go Cheatsheet. Se você combinar automação de navegador com pipelines de LLM em Go, os Go SDKs for Ollama e Reranking with Ollama and Qwen3 Embedding in Go são referências úteis.

Posts relacionados

• Go Cheatsheet
• Go Linters: Essential Tools for Code Quality
• Go Project Structure: Practices & Patterns
• Dependency Injection in Go: Patterns & Best Practices
• Go SDKs for Ollama - comparison with examples
• Reranking text documents with Ollama and Qwen3 Embedding model - in Go
• chromedp - Go package
• chromedp examples
• Playwright for Go
• playwright-go GitHub
• ZenRows Scraper API Go SDK
• ZenRows documentation
• Chrome DevTools Protocol