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

Escolher a pilha correta de automatização do navegador e web scraping em Go afeta a velocidade, a manutenção e onde o seu código será executado.

Este resumo compara chromedp, Playwright for Go, Selenium (cliente Go) e ZenRows com exemplos de código para cada um, para que você possa escolher a melhor opção para scraping, testes E2E ou automação programada.

TL;DR - Comparação rápida

Quando usar cada uma

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

Playwright for Go - Bindings de Go mantidos pela comunidade para Microsoft Playwright. Uma API para Chromium, Firefox e WebKit; aguarda automaticamente elementos; seletores e funcionalidades modernos. Use-o quando você precisar de testes E2E multi-navegador ou uma API focada em testes e estiver disposto a fazer uma instalação extra para os navegadores.

Selenium (Go) - 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 do driver ou conecta-se a uma grade. Use-o para suítes legadas ou quando precisar do ecossistema mais amplo; para novos projetos em Go, o chromedp ou o Playwright for Go geralmente simplificam a configuração.

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

Para uma referência rápida sobre ferramentas e estrutura do Go, veja Estrutura de Projetos Go: Práticas & Padrões; manter a automação em um pacote dedicado se encaixa bem com internal/ ou pkg/.

chromedp: puro Go, apenas Chrome

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

go get -u github.com/chromedp/chromedp

Exemplo: navegar, ler título e extrair texto por seletor. Todas as ações são executadas 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("Título:", title)
	fmt.Println("Título da seção:", bodyText)
}

Exemplo: clicar e ler o HTML atualizado. Use chromedp.Click e chromedp.OuterHTML (ou chromedp.InnerHTML) com chromedp.ByQuery. Substitua targetURL pela sua página (por exemplo, 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 executa headless. Para mostrar uma janela ou alterar flags, use um alocador personalizado (veja o exemplo de ExecAllocator do chromedp). Para Docker ou CI, a imagem chromedp/headless-shell fornece uma construção de Chrome headless menor que o chromedp pode usar diretamente – assim, você pode executar o 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, auto-aguarda

O Playwright for Go oferece as mesmas funcionalidades de múltiplos navegadores e auto-aguarda do Playwright em outras linguagens. Instale a biblioteca e, em seguida, 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 o Chromium, abrir uma página, capturar uma imagem. 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("não foi possível iniciar o Playwright: %v", err)
	}
	defer pw.Stop()

	browser, err := pw.Chromium.Launch(playwright.BrowserTypeLaunchOptions{Headless: playwright.Bool(true)})
	if err != nil {
		log.Fatalf("não foi possível iniciar o Chromium: %v", err)
	}
	defer browser.Close()

	page, err := browser.NewPage()
	if err != nil {
		log.Fatalf("não foi possível criar a página: %v", err)
	}

	_, err = page.Goto("https://example.com")
	if err != nil {
		log.Fatalf("não foi possível acessar a página: %v", err)
	}

	_, err = page.Screenshot(playwright.PageScreenshotOptions{Path: playwright.String("example.png")})
	if err != nil {
		log.Fatalf("não foi possível capturar a imagem: %v", err)
	}
}

Exemplo: preencher um formulário e obter o texto. O Playwright aguarda automaticamente elementos para serem ações, reduzindo a instabilidade em comparação com o CDP bruto ou o Selenium sem waits explícitos.

	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 tanto para scraping quanto para testes: navegar, clicar, extrair HTML ou texto, e opcionalmente controlar o Scraping Browser do ZenRows via seu endpoint compatível com CDP/Playwright quando precisar de anti-bot ou proxies.

Selenium (cliente Go)

A API do WebDriver do Selenium está disponível em Go via clientes comunitários (ex: tebeka/selenium). Você executa um driver de navegador (ChromeDriver, GeckoDriver) ou conecta-se a uma grade; o código Go envia comandos do WebDriver. Sim, o Selenium suporta Go – você só precisa gerenciar o processo do driver ou usar uma grade de nuvem.

Exemplo: conectar-se ao ChromeDriver, navegar, obter o 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("Título:", title)
}

Para novos projetos em Go, o chromedp (sem driver) ou o Playwright for Go (multi-navegador, auto-aguarda) geralmente são mais fáceis; use o Selenium quando já tiver suites de WebDriver ou precisar de uma grade específica.

ZenRows: API de Scraping do Go

O ZenRows expõe uma API de Scraping (HTTP) e um Browser de Scraping opcional (compatível com CDP/Playwright). Do Go, você normalmente usa a API de Scraping: envie um GET (ou POST) com a URL do alvo e as opções; o ZenRows retorna o HTML renderizado ou outros formatos. Não há navegador local para gerenciar. Use o ZenRows quando o objetivo for scraping e você precisar de proxies, bypass de anti-bot ou tratamento de CAPTCHA; para automação local simples, o chromedp ou o 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 Scraping do ZenRows. Defina sua chave 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("SUA_CHAVE_API"),
	)

	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("Tamanho do corpo:", len(response.Body()))
	fmt.Println("Status:", response.Status())
}

Exemplo: renderização de 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), retenções (WithMaxRetryCount, WithRetryWaitTime) e outras opções; veja as documentações do SDK do ZenRows Scraper API para Go.

Resumo

• chromedp: Puro Go, CDP, apenas Chrome; sem driver. Use para automação e scraping rápidos com baixo custo. Execute em Docker com chromedp/headless-shell se necessário.
• Playwright for Go: Multi-navegador, auto-aguarda, amigável para testes. Use para testes E2E ou quando quiser uma API única para Chromium, Firefox e WebKit; também adequado para scraping.
• Selenium (Go): WebDriver do Go; driver ou grade necessários. Use quando estiver mantendo suites existentes de Selenium ou precisar de uma grade específica.
• ZenRows: API de Scraping (e Browser de Scraping) do Go. Use quando o objetivo for scraping e você precisar de resiliência contra bloqueios, limites de taxa e anti-bot.

Para mais práticas de Go – linters, layout de projeto e injeção de dependência – veja Linters para Go: Ferramentas Essenciais para Qualidade do Código, Injeção de Dependência em Go: Padrões & Boas Práticas, e o Cheatsheet de Go. Se você combinar automação de navegador com pipelines de LLM em Go, os SDKs do Ollama para Go e Reordenação com Ollama e Qwen3 Embedding em Go são referências úteis.

Posts relacionados

• Cheatsheet de Go
• Linters para Go: Ferramentas Essenciais para Qualidade do Código
• Estrutura de Projetos Go: Práticas & Padrões
• Injeção de Dependência em Go: Padrões & Boas Práticas
• SDKs do Ollama para Go - comparação com exemplos
• Reordenação de documentos de texto com Ollama e Qwen3 Embedding em Go
• chromedp - pacote Go
• Exemplos do chromedp
• Playwright for Go
• playwright-go no GitHub
• SDK do ZenRows Scraper API para Go
• Documentação do ZenRows
• Chrome DevTools Protocol