How Playwright connects to remote browsers.

Playwright normally launches browsers on the same machine. Remote operation changes that ownership boundary. A browser server owns the browser process. Your application owns the Playwright client.

Playwright's native connect method attaches remotely. A BrowserServer can produce its endpoint. Playwright 1.59 lets a launched Browser create one. It uses browser.bind().

The endpoint must match Playwright's protocol. Any WebSocket address is insufficient. A Chrome debugging socket is different. A browser viewing URL is also different.

Connection success proves protocol compatibility. It does not prove task reliability. State, artifacts, timeouts, and cleanup still matter. Evaluate the whole operating contract.

Playwright 1.59 added browser.bind(). It makes a launched browser available to other Playwright clients.

The default binding uses a named pipe. Host and port create a WebSocket endpoint. Port zero lets the operating system choose an available port. Playwright 1.59.1 returned a malformed WebSocket endpoint. The corrected construction appears in Playwright 1.60.

Browser.bind creates producer-side access. BrowserType.connect performs consumer-side attachment. connectOverCDP remains a different Chromium-only protocol.

Browser.unbind stops new connections. Keep every exposed endpoint inside a trusted boundary.

Legba publishes a proposed public-preview contract. It provides illustrative endpoint shapes. It publishes no callable host or key issuer. Do not treat the examples as a live service.

The proposed docs sketch REST instance lifecycle. They show create, list, and destroy operations. These examples describe a possible contract, not currently callable endpoints.

Illustrative responses include an access_url. The proposal never defines a Playwright protocol. It never defines a CDP protocol.

Therefore, current Playwright compatibility is undocumented. An illustrative access_url cannot establish compatibility alone. Wait for an explicit protocol contract. Recheck canonical docs before implementation.

Playwright exposes two relevant remote attachment methods. They do not offer equivalent behavior. Native connect speaks Playwright's protocol. connectOverCDP speaks Chrome DevTools Protocol.

Native connect requires compatible Playwright versions. Client and server major versions must match. Minor versions must also match. Patch versions may differ.

connectOverCDP supports Chromium browsers only. Official documentation describes significantly lower fidelity. Some Playwright capabilities may behave differently. Native protocol remains the stronger default.

A provider's REST URL is neither path automatically. The provider must name the transport. It must document authentication and versions. Otherwise, compatibility remains unknown.

A Playwright connection controls browser commands. It does not choose an IP source. Playwright documents generic HTTP and SOCKS proxies. It does not provide residential network service.

BrowserContext isolates cookies and local storage. A new context alone promises no new IP. Proxy configuration controls network egress. Provider sessions define reuse and rotation.

Remote providers place proxy settings differently. Browserbase uses session creation. Browserless uses connection parameters. Follow each provider's current contract.

Legba's proposed preview sketches REST instance lifecycle. It publishes no Playwright or CDP endpoint. It publishes no proxy or geography field. Do not infer a residential Playwright integration.

The following pattern mirrors Playwright's documented method. It deliberately uses a generic environment variable. Replace it only with provider documentation. Never transform an unrelated access URL.

The client connects before creating a context. That context receives its own pages. The example closes context resources explicitly. It then closes the connected browser object.

This example is provider-neutral. It uses a placeholder endpoint. It was not tested against Legba. It does not prove Legba compatibility.

Production code needs provider-specific lifecycle handling. It also needs retries and artifact capture. Those details depend on published contracts. Keep them outside generic connection helpers.

Playwright browser contexts provide independent sessions. They isolate cookies and local storage. Multiple contexts can share one browser. Each context still needs explicit ownership.

Authentication state can reduce repeated login work. Playwright stores reusable state through storageState. That file may contain sensitive cookies. It may also contain sensitive headers.

Playwright recommends keeping state outside repositories. Add its directory to version-control exclusions. Delete expired state when appropriate. Never expose reusable state through client bundles.

Remote providers add another storage boundary. Ask where context data resides. Ask whether profiles persist after termination. Ask how deletion is verified. Document every answer before reuse.

Remote debugging needs durable evidence. A local stack trace may be insufficient. Browser actions happened elsewhere. Network timing and page state can disappear quickly.

Playwright tracing records browser operations. Trace Viewer exposes actions and metadata. Traces can include screenshots and snapshots. Their contents may include sensitive application data.

Playwright Test supports retry-focused tracing. Official guidance recommends tracing the first retry. That balances evidence against performance costs. Plain library usage requires explicit tracing calls.

Artifact transfer remains provider-specific. Ask where trace files are written. Ask whether disconnection preserves them. Ask when downloads become available. Test retrieval during partial failures.

Playwright exposes browser and context lifecycle methods. The browser close method clears connected contexts. It then disconnects the client. Close contexts first for orderly artifact flushing.

Provider infrastructure may have another lifecycle. A disconnected client may leave resources active. The provider's REST contract must own termination. Browser closure never proves provider termination.

Failures can occur between every cleanup step. Context closure can fail. Client disconnection can race network loss. Provider termination can also fail independently.

Use resource identifiers for reconciliation. List remaining resources after interruptions. Retry only documented safe operations. Confirm a final terminated state. Keep browser errors and lifecycle errors separate.

Begin with one production-shaped Playwright task. Include navigation and authentication. Include expected outputs and artifacts. Include a normal failure path.

Write compatibility requirements before choosing providers. Name the desired connection method. Name the supported browser engines. Name acceptable version constraints.

Legba's proposed lifecycle contract is a design reference only. It lacks Playwright protocol details. It also lacks CDP endpoint details. Current evidence cannot justify implementation.

Return after published compatibility appears. Then test the exact documented endpoint. Pin compatible Playwright versions. Recheck documentation before each upgrade. Keep guessed endpoints out of production.