Browser Automation i Go: Selenium, chromedp, Playwright, ZenRows

Välj rätt browserautomatiseringsstack och webscraping i Go påverkar hastighet, underhåll och var din kod kör.

Den här översikten jämför chromedp, Playwright for Go, Selenium (Go-klient) och ZenRows med kodexempel för varje - så du kan välja den bästa lösningen för scraping, E2E-testning eller schemalagd automatisering.

TL;DR - Snabb jämförelse

När att använda vilket

chromedp - Idiomatic Go-bibliotek som styr Chrome/Chromium via Chrome DevTools Protocol (CDP). Inget WebDriver eller Selenium-server; inga externa körningar. Idealiskt för scraping och lättviktig automatisering när Chrome-endast är tillåtet. Den främsta skillnaden från Playwright for Go är att chromedp är ren Go och Chrome-endast, medan Playwright stöder flera webbläsare och kräver installation av webbläsarbilder.

Playwright for Go - Community-maintained Go-bindningar för Microsoft Playwright. En API för Chromium, Firefox och WebKit; automatisk väntan på element; moderna selektorer och funktioner. Använd den när du behöver tvärbrowser E2E-testning eller en testfokuserad API och är okej med en extra installationssteg för webbläsare.

Selenium (Go) - Den klassiska WebDriver-metoden: en Go-klient som pratar med en webbläsardrivrutin (ChromeDriver, GeckoDriver, osv.). Selenium stöder Go; du kör en drivrutin eller ansluter till en grid. Använd det för äldre system eller när du behöver det bredaste ekosystemet; för nya Go-projekt förenklar ofta chromedp eller Playwright for Go inställningen.

ZenRows - Inte en drivrutinbibliotek utan en Scraper API (och valfri Scraping Browser) som du anropar från Go över HTTP. ZenRows hanterar headless webbläsare, JS-rendering, residensiala proxyer, anti-bot-överföring och CAPTCHA. Använd det när ditt mål är scraping och du stöter på block eller hastighetsbegränsningar; för lokala E2E-tester är chromedp eller Playwright ofta tillräckliga.

För en snabb referens till Go-verktyg och struktur, se Go Project Structure: Practices & Patterns; att hålla automatisering i en dedikerad paket passar bra med internal/ eller pkg/.

chromedp: ren Go, Chrome-endast

chromedp kräver inga tredjepartsbinärer: den implementerar CDP i Go och startar (eller ansluter till) Chrome/Chromium. Installera:

go get -u github.com/chromedp/chromedp

Exempel: navigera, läs titel och extrahera text med selektor. Alla åtgärder köras inom chromedp.Run; använd chromedp.ByQuery för CSS-selektorer.

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("Titel:", title)
	fmt.Println("Rubrik:", bodyText)
}

Exempel: klicka och läs uppdaterad HTML. Använd chromedp.Click och chromedp.OuterHTML (eller chromedp.InnerHTML) med chromedp.ByQuery. Byt ut targetURL med din sida (t.ex. ett testserver eller någon 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),
	)

Som standard kör Chrome headless. För att visa ett fönster eller ändra flaggor, använd en anpassad allocators (se chromedp ExecAllocator example). För Docker eller CI, tillhandahåller chromedp/headless-shell en mindre headless Chrome-byggt som chromedp kan använda direkt - så du kan köra chromedp i headless miljöer utan att installera Chrome på värd.

Fler exempel (skärmbilder, PDF, formulär, cookies) finns i chromedp/examples repositoryn.

Playwright for Go: tvärbrowser, auto-vänta

Playwright for Go ger dig samma flerbrowsers och auto-vänta funktioner som Playwright i andra språk. Installera biblioteket och sedan webbläsarbilder:

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

Exempel: starta Chromium, öppna en sida, ta en skärmbild. Du kan använda pw.Firefox eller pw.WebKit för andra motorer.

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

Exempel: fyll ett formulär och få text. Playwright väntar automatiskt på element att bli åtgärdbara, vilket minskar flakighet jämfört med rå CDP eller Selenium utan explicita väntan.

	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)

Du kan använda Playwright for Go för webbscraping samt testning: navigera, klicka, extrahera HTML eller text, och eventuellt driva ZenRows Scraping Browser via dess CDP/Playwright-kompatibla endpoint när du behöver anti-bot eller proxyer.

Selenium (Go-klient)

Seleniums WebDriver API är tillgänglig i Go via community-klienter (t.ex. tebeka/selenium). Du kör en webbläsardrivrutin (ChromeDriver, GeckoDriver) eller ansluter till en grid; Go-koden skickar WebDriver-kommandon. Ja, Selenium stöder Go - du behöver bara hantera drivrutinprocessen eller använda en molngrid.

Exempel: anslut till ChromeDriver, navigera, få titel. Drivrutinen måste köras (t.ex. chromedriver --port=4444 eller Selenium Manager i 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("Titel:", title)
}

För nya Go-projekt är chromedp (ingen drivrutin) eller Playwright for Go (flerbrowsers, auto-vänta) ofta enklare; använd Selenium när du redan har WebDriver-system eller behöver en specifik grid.

ZenRows: Scraper API från Go

ZenRows exponerar en Scraper API (HTTP) och en valfri Scraping Browser (CDP/Playwright-kompatibel). Från Go använder du vanligtvis Scraper API: skicka en GET (eller POST) med mål-URL och alternativ; ZenRows returnerar den renderade HTML eller andra format. Inget lokalt webbläsare att hantera. Använd ZenRows när scraping är målet och du behöver proxyer, anti-bot-överföring eller CAPTCHA-hantering; för enkla lokala automatiseringar är chromedp eller Playwright tillräckliga.

Installera den officiella Go SDK:

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

Exempel: enkel GET med ZenRows Scraper API. Ställ in din API-nyckel via klienten eller ZENROWS_API_KEY miljövariabeln.

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

Exempel: JS-rendering och premiumproxyer. Anpassa beteende med 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()

SDK:n stöder flödesgräns (med WithMaxConcurrentRequests), omförsök (WithMaxRetryCount, WithRetryWaitTime) och andra alternativ; se ZenRows Scraper API Go SDK dokumentationen.

Sammanfattning

• chromedp: Ren Go, CDP, Chrome-endast; ingen drivrutin. Använd för snabb, lättviktig automatisering och scraping. Kör i Docker med chromedp/headless-shell om det behövs.
• Playwright for Go: Flerbrowsers, auto-vänta, testvänlig. Använd för E2E-testning eller när du vill ha en API för Chromium, Firefox och WebKit; även bra för scraping.
• Selenium (Go): WebDriver från Go; drivrutin eller grid krävs. Använd när du underhåller befintliga Selenium-system eller behöver en specifik grid.
• ZenRows: Scraper API (och Scraping Browser) från Go. Använd när scraping är fokus och du behöver motståndskraft mot block, hastighetsbegränsningar och anti-bot.

För fler Go-praktiker-linter, projektlayout och beroendeinjektion, se Go Linters: Essential Tools for Code Quality, Dependency Injection in Go: Patterns & Best Practices, och Go Cheatsheet. Om du kombinerar webbläsarautomatisering med LLM-pipelines i Go, är Go SDKs for Ollama och Reranking with Ollama and Qwen3 Embedding in Go användbara referenser.

Relaterade inlägg

• 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