L'automazione del browser in Go: Selenium, chromedp, Playwright, ZenRows

Scegliere la giusta stack di automazione del browser e web scraping in Go influisce sulla velocità, sulla manutenzione e su dove esegue il codice.

Questo riepilogo confronta chromedp, Playwright for Go, Selenium (client Go) e ZenRows con esempi di codice per ciascuno, in modo che possiate scegliere l’opzione migliore per il web scraping, i test E2E o l’automazione programmata.

TL;DR - Confronto rapido

Quando utilizzare quale

chromedp - Libreria idiomatica Go che utilizza Chrome/Chromium tramite il Chrome DevTools Protocol (CDP). Non necessita di un server WebDriver o Selenium; non richiede un runtime esterno. Ideale per il scraping e l’automazione leggera quando l’utilizzo esclusivo di Chrome è accettabile. La principale differenza rispetto a Playwright for Go è che chromedp è puramente in Go e supporta solo Chrome, mentre Playwright supporta diversi browser e richiede l’installazione di binari del browser.

Playwright for Go - Binding Go della comunità per Microsoft Playwright. Un’unica API per Chromium, Firefox e WebKit; attesa automatica per gli elementi; selezioni e funzionalità moderne. Utilizzalo quando hai bisogno di test E2E multi-browser o di un’API orientata ai test e sei disposto a installare i browser con un ulteriore passo.

Selenium (Go) - L’approccio classico WebDriver: un client Go comunica con un driver del browser (ChromeDriver, GeckoDriver, ecc.). Selenium supporta Go; puoi eseguire un processo driver o connettermi a una griglia. Utilizzalo per le suite legacy o quando hai bisogno dell’ecosistema più ampio; per nuovi progetti Go, chromedp o Playwright for Go spesso semplificano l’installazione.

ZenRows - Non è una libreria driver, ma un Scraper API (e opzionalmente un Browser di Scraping) che chiama da Go tramite HTTP. ZenRows gestisce i browser headless, il rendering JS, i proxy residenziali, il bypass anti-bot e i CAPTCHA. Utilizzalo quando l’obiettivo è il scraping e si incontrano blocchi o limiti di velocità; per i test E2E locali, chromedp o Playwright sono spesso sufficienti.

Per un riferimento rapido degli strumenti Go e della struttura, vedi Struttura del progetto Go: Pratiche & Pattern; mantenere l’automazione in un pacchetto dedicato si adatta bene a internal/ o pkg/.

chromedp: puro Go, solo Chrome

chromedp non richiede alcun binario terze parti: implementa il CDP in Go e avvia (o si connette a) Chrome/Chromium. Installa:

go get -u github.com/chromedp/chromedp

Esempio: naviga, leggi il titolo e estrai il testo tramite un selettore. Tutte le azioni vengono eseguite all’interno di chromedp.Run; utilizza chromedp.ByQuery per i selettori 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("Titolo:", title)
	fmt.Println("Intestazione:", bodyText)
}

Esempio: clicca e leggi l’HTML aggiornato. Utilizza chromedp.Click e chromedp.OuterHTML (o chromedp.InnerHTML) con chromedp.ByQuery. Sostituisci targetURL con la tua pagina (ad esempio un server di test o qualsiasi 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),
	)

Di default, Chrome esegue in modalità headless. Per visualizzare una finestra o modificare i flag, utilizza un allocatore personalizzato (vedi l’esempio chromedp ExecAllocator). Per Docker o CI, l’immagine chromedp/headless-shell fornisce una costruzione headless Chrome più piccola che chromedp può utilizzare direttamente - in modo da poter eseguire chromedp in ambienti headless senza installare Chrome sull’host.

Ulteriori esempi (screenshot, PDF, form, cookie) sono disponibili nel repository chromedp/examples.

Playwright for Go: cross-browser, auto-wait

Playwright for Go ti offre le stesse funzionalità multi-browser e auto-wait di Playwright in altre lingue. Installa la libreria e quindi i binari del browser:

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

Esempio: avvia Chromium, apri una pagina, prendi uno screenshot. Puoi utilizzare pw.Firefox o pw.WebKit per altri motori.

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

Esempio: compila un modulo e ottieni del testo. Playwright attenda automaticamente che gli elementi siano azionabili, riducendo così l’incertezza rispetto a CDP o Selenium senza attese esplicite.

	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)

Puoi utilizzare Playwright for Go per il web scraping nonché per i test: naviga, clicca, estrai HTML o testo e, se necessario, utilizza l’endpoint compatibile con CDP/Playwright di ZenRows’ Scraping Browser.

Selenium (client Go)

L’API WebDriver di Selenium è disponibile in Go tramite client della comunità (ad esempio tebeka/selenium). Esegui un driver del browser (ChromeDriver, GeckoDriver) o connettiti a una griglia; il codice Go invia comandi WebDriver. Sì, Selenium supporta Go - devi solo gestire il processo del driver o utilizzare una griglia cloud.

Esempio: connettiti a ChromeDriver, naviga, ottieni il titolo. Il driver deve essere in esecuzione (ad esempio chromedriver --port=4444 o Selenium Manager in 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("Titolo:", title)
}

Per nuovi progetti Go, chromedp (nessun driver) o Playwright for Go (multi-browser, auto-wait) sono spesso più semplici; utilizza Selenium quando devi mantenere le suite WebDriver esistenti o hai bisogno di una griglia specifica.

ZenRows: Scraper API da Go

ZenRows espone un Scraper API (HTTP) e un Scraping Browser opzionale (compatibile con CDP/Playwright). Da Go si utilizza tipicamente l’Scraper API: invia un GET (o POST) con l’URL di destinazione e le opzioni; ZenRows restituisce l’HTML renderizzato o altri formati. Nessun browser locale da gestire. Utilizza ZenRows quando lo scopo è il scraping e hai bisogno di proxy, bypass anti-bot o gestione CAPTCHA; per semplici automazioni locali, chromedp o Playwright sono sufficienti.

Installa l’SDK Go ufficiale:

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

Esempio: GET semplice con l’API Scraper di ZenRows. Imposta la tua chiave API tramite il client o la variabile d’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("Lunghezza del corpo:", len(response.Body()))
	fmt.Println("Stato:", response.Status())
}

Esempio: rendering JS e proxy premium. Personalizza il comportamento 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()

L’SDK supporta i limiti di concorrenza (WithMaxConcurrentRequests), i retry (WithMaxRetryCount, WithRetryWaitTime) e altre opzioni; vedi le documentazioni dell’SDK ZenRows Scraper API Go.

Riepilogo

• chromedp: Puro Go, CDP, solo Chrome; nessun driver. Utilizzalo per l’automazione veloce e a basso overhead e il scraping. Esegui in Docker con chromedp/headless-shell se necessario.
• Playwright for Go: Multi-browser, auto-wait, test-friendly. Utilizzalo per i test E2E o quando desideri un’unica API per Chromium, Firefox e WebKit; è anche adatto per il scraping.
• Selenium (Go): WebDriver da Go; necessario un driver o una griglia. Utilizzalo quando devi mantenere le suite Selenium esistenti o hai bisogno di una griglia specifica.
• ZenRows: Scraper API (e Scraping Browser) da Go. Utilizzalo quando lo scopo è il scraping e hai bisogno di resilienza contro blocchi, limiti di velocità e anti-bot.

Per ulteriori pratiche Go - linter, layout del progetto e iniezione di dipendenze - vedi Go Linters: Strumenti essenziali per la qualità del codice, Iniezione di dipendenze in Go: Pattern & Best Practices, e il Go Cheatsheet. Se combini l’automazione del browser con i pipeline LLM in Go, gli SDK Go per Ollama e Reranking con Ollama e Qwen3 Embedding in Go sono utili riferimenti.

Post correlati

• 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