Automatización de Navegadores en Go: Selenium, chromedp, Playwright, ZenRows

Elegir la pila correcta de automatización del navegador y web scraping en Go afecta la velocidad, el mantenimiento y donde se ejecuta tu código.

Este resumen compara chromedp, Playwright for Go, Selenium (cliente para Go) y ZenRows desde Go, con ejemplos de código para cada uno, para que puedas elegir la mejor opción para el scraping, pruebas E2E o automatización programada.

TL;DR - Comparación rápida

Cuándo usar cada una

chromedp - Biblioteca idiomática de Go que controla Chrome/Chromium a través del Chrome DevTools Protocol (CDP). No requiere WebDriver ni servidor de Selenium; no hay entorno de ejecución externo. Ideal para scraping y automatización ligera cuando Chrome sea aceptable. La principal diferencia con Playwright for Go es que chromedp es puro Go y solo funciona con Chrome, mientras que Playwright soporta múltiples navegadores y requiere instalar binarios de navegadores.

Playwright for Go - Vinculaciones de Go mantenido por la comunidad para Microsoft Playwright. Una sola API para Chromium, Firefox y WebKit; espera automática de elementos; selectores y características modernos. Úsalo cuando necesites pruebas E2E multi-navegador o una API enfocada en pruebas, y estés dispuesto a aceptar un paso adicional de instalación para los navegadores.

Selenium (Go) - El enfoque clásico de WebDriver: un cliente de Go se conecta a un driver de navegador (ChromeDriver, GeckoDriver, etc.). Selenium sí soporta Go; ejecutas un proceso de driver o te conectas a una red. Úsalo para suites legadas o cuando necesites el ecosistema más amplio; para nuevos proyectos en Go, chromedp o Playwright for Go suelen simplificar la configuración.

ZenRows - No es una biblioteca de driver, sino una API de scraping (y opcionalmente un navegador de scraping) que llamas desde Go mediante HTTP. ZenRows maneja navegadores sin cabeza, renderizado de JS, proxies residenciales, bypass de anti-bot y CAPTCHA. Úsalo cuando tu objetivo sea el scraping y te encuentres con bloqueos o límites de tasa; para pruebas E2E locales, chromedp o Playwright suelen ser suficientes.

Para una referencia rápida de herramientas de Go y estructura, consulta Estructura de proyectos en Go: Prácticas y patrones; mantener la automatización en un paquete dedicado se adapta bien a internal/ o pkg/.

chromedp: puro Go, solo Chrome

chromedp no requiere binarios de terceros: implementa el CDP en Go y inicia (o se conecta a) Chrome/Chromium. Instalación:

go get -u github.com/chromedp/chromedp

Ejemplo: navegar, leer el título y extraer texto mediante selector. Todas las acciones se ejecutan dentro de chromedp.Run; usa chromedp.ByQuery para selectores 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("Encabezado:", bodyText)
}

Ejemplo: hacer clic y leer el HTML actualizado. Usa chromedp.Click y chromedp.OuterHTML (o chromedp.InnerHTML) con chromedp.ByQuery. Reemplaza targetURL con tu página (por ejemplo, un servidor de prueba o cualquier 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 defecto, Chrome se ejecuta sin cabeza. Para mostrar una ventana o cambiar flags, usa un allocador personalizado (ver el ejemplo de ExecAllocator de chromedp). Para Docker o CI, la imagen chromedp/headless-shell proporciona una construcción de Chrome sin cabeza más pequeña que chromedp puede usar directamente, por lo que puedes ejecutar chromedp en entornos sin cabeza sin instalar Chrome en el host.

Más ejemplos (capturas de pantalla, PDF, formularios, cookies) están en el repositorio chromedp/examples.

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

Playwright for Go ofrece las mismas características de multi-navegador y espera automática que Playwright en otros idiomas. Instala la biblioteca y luego los binarios del navegador:

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

Ejemplo: iniciar Chromium, abrir una página, tomar una captura de pantalla. Puedes usar pw.Firefox o pw.WebKit para otros motores.

package main

import (
	"log"

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

func main() {
	pw, err := playwright.Run()
	if err != nil {
		log.Fatalf("no se pudo iniciar Playwright: %v", err)
	}
	defer pw.Stop()

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

	page, err := browser.NewPage()
	if err != nil {
		log.Fatalf("no se pudo crear la página: %v", err)
	}

	_, err = page.Goto("https://example.com")
	if err != nil {
		log.Fatalf("no se pudo navegar: %v", err)
	}

	_, err = page.Screenshot(playwright.PageScreenshotOptions{Path: playwright.String("example.png")})
	if err != nil {
		log.Fatalf("no se pudo tomar la captura de pantalla: %v", err)
	}
}

Ejemplo: rellenar un formulario y obtener texto. Playwright espera automáticamente que los elementos sean accionables, lo que reduce la volatilidad en comparación con CDP o Selenium sin 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)

Puedes usar Playwright for Go tanto para scraping web como para pruebas: navegar, hacer clic, extraer HTML o texto, y opcionalmente controlar el Scraping Browser de ZenRows a través de su endpoint compatible con CDP/Playwright cuando necesites anti-bot o proxies.

Selenium (cliente para Go)

La API de WebDriver de Selenium está disponible en Go a través de clientes comunitarios (por ejemplo, tebeka/selenium). Ejecutas un driver de navegador (ChromeDriver, GeckoDriver) o te conectas a una red; el código de Go envía comandos de WebDriver. Sí, Selenium sí soporta Go, pero necesitas gestionar el proceso del driver o usar una red en la nube.

Ejemplo: conectar con ChromeDriver, navegar, obtener título. El driver debe estar en ejecución (por ejemplo, chromedriver --port=4444 o Selenium Manager en 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 nuevos proyectos en Go, chromedp (sin driver) o Playwright for Go (multi-navegador, espera automática) suelen ser más fáciles; usa Selenium cuando ya tengas suites de WebDriver o necesites una red específica.

ZenRows: API de scraping desde Go

ZenRows expone una API de scraping (HTTP) y un navegador de scraping opcional (compatible con CDP/Playwright). Desde Go normalmente usas la API de scraping: envía un GET (o POST) con la URL objetivo y opciones; ZenRows devuelve el HTML renderizado u otros formatos. No hay navegador local que gestionar. Usa ZenRows cuando el objetivo sea el scraping y necesites proxies, bypass de anti-bot o manejo de CAPTCHA; para automatización local simple, chromedp o Playwright suelen ser suficientes.

Instala el SDK oficial de Go:

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

Ejemplo: GET simple con la API de scraping de ZenRows. Establece tu clave API mediante el cliente o la variable de entorno 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("Longitud del cuerpo:", len(response.Body()))
	fmt.Println("Estado:", response.Status())
}

Ejemplo: renderizado de JS y proxies premium. Personaliza el comportamiento con 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()

El SDK soporta límites de concurrencia (WithMaxConcurrentRequests), reintentos (WithMaxRetryCount, WithRetryWaitTime) y otras opciones; consulta las documentaciones del SDK de la API de scraping de ZenRows.

Resumen

• chromedp: Puro Go, CDP, solo Chrome; sin driver. Úsalo para automatización rápida y de bajo consumo y scraping. Ejecútalo en Docker con chromedp/headless-shell si es necesario.
• Playwright for Go: Multi-navegador, espera automática, amigable para pruebas. Úsalo para pruebas E2E o cuando desees una API única para Chromium, Firefox y WebKit; también es adecuado para scraping.
• Selenium (Go): WebDriver desde Go; se requiere un driver o una red. Úsalo cuando mantengas suites legadas de Selenium o necesites una red específica.
• ZenRows: API de scraping (y navegador de scraping) desde Go. Úsalo cuando el objetivo sea el scraping y necesites resiliencia ante bloqueos, límites de tasa y anti-bot.

Para más prácticas en Go-linters, estructura de proyectos y inyección de dependencias, consulta Linter para Go: Herramientas esenciales para la calidad del código, Inyección de dependencias en Go: patrones y mejores prácticas, y la Guía de referencia rápida para Go. Si combinas automatización de navegador con pipelines de LLM en Go, las SDKs para Ollama en Go y Reclasificación con Ollama y Qwen3 Embedding en Go son referencias útiles.

Posts relacionados

• Guía rápida de Go
• Linter para Go: Herramientas esenciales para la calidad del código
• Estructura de proyectos en Go: Prácticas y patrones
• Inyección de dependencias en Go: patrones y mejores prácticas
• SDKs para Ollama en Go - comparación con ejemplos
• Reclasificación de documentos de texto con Ollama y Qwen3 Embedding modelo - en Go
• chromedp - paquete Go
• ejemplos de chromedp
• Playwright for Go
• playwright-go en GitHub
• SDK de la API de scraping de ZenRows para Go
• documentación de ZenRows
• Chrome DevTools Protocol