Playwright for Go is a browser automation library, distributed as the Go module github.com/mxschmitt/playwright-go under the MIT licence, that drives Chromium, Firefox and WebKit through a single API and is aimed at Go developers who need programmatic control of real browsers.

What it is

Playwright for Go is the Go binding of Playwright, a cross-browser automation toolkit. It exposes one API surface for three browser engines — the README pins Chromium 151.0.7922.34, Firefox 153.0 and WebKit 26.5 — and runs each of them in both headless and headed mode on Linux, macOS and Windows. The library is written in Go, is published as github.com/mxschmitt/playwright-go, carries the MIT licence, and ships with an API reference on pkg.go.dev, a set of example recipes in the repository's examples directory, and documentation hosted at playwright.dev.

The concrete problem it solves is automating browsers without leaving the Go ecosystem. It replaces hand-rolled, engine-specific driver plumbing — and, for teams already using Selenium, the task of assembling per-browser drivers and reconciling their differences — with a single package in which the same call sequence works against Chromium, Firefox or WebKit. In the registry it sits in Data & Analytics / Data Extraction & Web Scraping, and its own headline example is a scraper: a program that opens Hacker News, calls page.Locator(".athing").All(), and reads the current top-voted items. The same primitives support scripted browser workflows generally, not only scraping.

Key capabilities

• One API across three engines: Chromium 151.0.7922.34, Firefox 153.0 and WebKit 26.5, with headless and headed execution supported for all browsers on all platforms.
• A dedicated installer command: go run github.com/mxschmitt/playwright-go/cmd/[email protected] install, with a --with-deps flag that also installs the operating-system dependencies.
• Programmatic installation from application code through playwright.Install(), for cases where the driver and browsers are fetched at runtime rather than from a shell.
• Version coupling managed through go.mod: each minor version of the library requires a specific Playwright driver version, and the install command's version placeholder is meant to be replaced with the version already in use.
• Locator-based element access, shown in the README with page.Locator(".athing").All() alongside playwright.Run(), pw.Chromium.Launch(), browser.NewPage() and page.Goto().
• Cross-language documentation: the guides, concepts and API semantics on playwright.dev are shared across all Playwright languages, with only the code samples written in JavaScript.
• Repository topics covering automation, browser-automation, chromium, firefox, go, golang, headless, headless-chrome, playwright, selenium and webkit.

Who uses it and how

• Go teams building scrapers and crawlers against JavaScript-rendered pages, following the README's Hacker News example as a starting pattern.
• Projects that test or exercise a web application across all three engines on Linux, macOS and Windows rather than validating against a single browser.
• Services and CI jobs that provision browsers headlessly, using the install command's --with-deps flag where privileged installation of OS-level dependencies is possible.
• Applications that prefer to fetch the driver and browsers from Go code via playwright.Install(), typically where running a separate install step is inconvenient.
• Long-lived Go codebases that pin the library in go.mod and accept that a minor-version upgrade obliges them to move the driver version in step.

Getting started

Add the module with go get -u github.com/mxschmitt/playwright-go, then install the Playwright driver and browsers by running go run github.com/mxschmitt/playwright-go/cmd/[email protected] install --with-deps, replacing the version placeholder with the version recorded in your go.mod.

How it compares

Among the similar tools named in its own topic list, Selenium is the closest point of reference: both automate Chromium, Firefox and WebKit, but Playwright for Go presents a single library-managed driver install rather than a separate driver per engine, and its documentation is shared with the other Playwright language bindings. Developers who need a language other than Go would use one of those other bindings instead, since the concepts and API semantics are described as identical across them. No list of paid products it replaces is given here, so no licence or cost comparison beyond its MIT licence can be drawn.

When to use it — and when not to

A self-hoster takes on real operational work: the Playwright driver and three browser builds have to be installed on each machine, operating-system dependencies may require elevated privileges when --with-deps cannot be used, and the library's minor versions are locked to specific driver versions. Teams not writing Go should choose a different Playwright binding, and anyone wanting a fully managed, hosted browser service will not find one here. The README is functional but compact — it defers concepts and semantics to playwright.dev, so the repository itself is a thin reference rather than a complete guide.

go get -u github.com/mxschmitt/playwright-go

go run github.com/mxschmitt/playwright-go/cmd/[email protected] install --with-deps
# Or
go install github.com/mxschmitt/playwright-go/cmd/[email protected]
playwright install --with-deps

err := playwright.Install()

package main

import (
	"fmt"
	"log"

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

func main() {
	pw, err := playwright.Run()
	if err != nil {
		log.Fatalf("could not start playwright: %v", err)
	}
	browser, err := pw.Chromium.Launch()
	if err != nil {
		log.Fatalf("could not launch browser: %v", err)
	}
	page, err := browser.NewPage()
	if err != nil {
		log.Fatalf("could not create page: %v", err)
	}
	if _, err = page.Goto("https://news.ycombinator.com"); err != nil {
		log.Fatalf("could not goto: %v", err)
	}
	entries, err := page.Locator(".athing").All()
	if err != nil {
		log.Fatalf("could not get entries: %v", err)
	}
	for i, entry := range entries {
		title, err := entry.Locator("td.title > span > a").TextContent()
		if err != nil {
			log.Fatalf("could not get text content: %v", err)
		}
		fmt.Printf("%d: %s\n", i+1, title)
	}
	if err = browser.Close(); err != nil {
		log.Fatalf("could not close browser: %v", err)
	}
	if err = pw.Stop(); err != nil {
		log.Fatalf("could not stop Playwright: %v", err)
	}
}