What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Yes, Playwright can run browser automation remotely. You keep the Playwright client and test code, while a cloud provider launches and operates the browser. Start by proving your script locally, then replace the local launch call with the provider’s connection method. The exact endpoint, protocol, browser engines, concurrency, regions and debugging artifacts depend on that provider.
What “Playwright in the cloud” means
Playwright is the automation client and test framework. In a local run, Playwright launches browser binaries installed in the machine or CI worker. In a hosted run, your Node.js (or another language) process connects to a browser running in a provider-managed session.
The distinction matters: cloud execution is not one universal Playwright service. Browserbase documents a cloud session connected over Chrome DevTools Protocol (CDP). Browserless exposes a default CDP endpoint and documents connectOverCDP, while noting that some capabilities require Playwright’s native protocol. Other providers may expose a different API altogether.
Build a local baseline first
A local baseline gives you a known-good test before networking, authentication and provider limits are introduced. Playwright supports Chromium, Firefox and WebKit projects. Its bundled Chromium can be ahead of branded stable Chrome or Edge, and its WebKit build tracks WebKit rather than being a branded Safari build. Use branded channels when you specifically need a current public Chrome or Edge regression check or media-codec coverage.
#1 Best Overall
Install the test runner and browsers
npm i -D @playwright/test
npx playwright installUpdating the Playwright package can require running the browser installation command again so the matching browser revisions are present.
Create a minimal test
// tests/home.spec.js
const { test, expect } = require('@playwright/test');
test('homepage has the expected title', async ({ page }) => {
await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
await expect(page).toHaveTitle(/Example Domain/);
});Run it
npx playwright testOnce this passes, add the options your real workflow needs: device emulation, a branded browser channel, authentication state, traces, screenshots or video. Keep this test in source control; it is your comparison point when a hosted run fails.
When a cloud browser is useful
- Parallel execution: run many independent tests without provisioning and updating your own browser workers.
- Consistent environments: use provider-managed images instead of maintaining operating-system packages, fonts and browser binaries.
- Geography and data controls: select an available region when tests must run near an application or within a required jurisdiction.
- Hosted debugging: some services retain traces, recordings, reports or run metadata so failures can be inspected after the worker exits.
- Interactive automation: a long-lived remote session can support workflows that do not fit a short CI job.
Local execution is usually simpler for a single developer, offline work and fast feedback. Hosted execution adds credentials, network latency and provider-specific limits, so move only after the local behavior is understood.
Connect a Playwright client to a provider
The general sequence is the same even though APIs differ:
- Create or select a browser session with the provider’s SDK or HTTP API.
- Obtain the session’s connection endpoint and authenticate it without hard-coding secrets.
- Call the connection method documented for that endpoint: CDP for a CDP endpoint, or Playwright’s native protocol when the provider requires it.
- Reuse your normal
browser,contextandpagecode. - Close the context and browser, then end the cloud session according to the provider’s lifecycle rules.
Do not assume that a CDP connection supports every Playwright feature. Network interception with page.route(), APIRequestContext and non-Chromium browsers are examples Browserless documents as requiring its native Playwright protocol rather than its default CDP path. That limitation is specific to the documented Browserless endpoint, not a rule about every provider.
Provider example: Browserbase over CDP
Browserbase’s quickstart creates a cloud session, connects to it with Playwright over CDP, navigates to a real site, interacts with controls and extracts content. The account’s API key is required. The outline below shows the connection shape; use the current Browserbase SDK and endpoint values from its documentation because session APIs can change.
import { chromium } from 'playwright';
// Use Browserbase's current SDK/API to create a session.
// const session = await browserbase.sessions.create({ apiKey: process.env.BROWSERBASE_API_KEY });
// const cdpUrl = session.connectUrl;
const browser = await chromium.connectOverCDP(cdpUrl);
const context = browser.contexts()[0] || await browser.newContext();
const page = await context.newPage();
await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
console.log(await page.locator('body').innerText());
await context.close();
await browser.close();Store BROWSERBASE_API_KEY in your CI secret store. A failed session-creation request is different from a failed page load: log the provider request ID and session ID, but never print the API key or cookies.
Browserless and protocol choice
Browserless documents a default endpoint that speaks CDP, so an existing Chromium script can use chromium.connectOverCDP(). Its documentation distinguishes that route from Playwright’s own server protocol and says capabilities such as page.route(), APIRequestContext and browsers other than Chromium require the native protocol path. Check the endpoint-specific documentation before converting a test suite; a successful connection does not prove feature parity.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Local versus hosted execution
| Decision area | Local Playwright | Cloud browser |
|---|---|---|
| Setup and maintenance | Install Playwright and matching browser binaries on each worker. | Provider maintains browser workers; you maintain credentials and client compatibility. |
| Engines and versions | Chromium, Firefox and WebKit projects, plus optional branded Chrome/Edge channels. | Only the engines, versions and channels the selected service exposes. |
| Protocol | Full Playwright-native launch and connection APIs. | May be CDP, native Playwright protocol or a provider SDK; capabilities differ. |
| Concurrency | Bound by your CPU, memory and worker count. | Bound by plan, workspace or session limits; Microsoft’s product page currently states up to 50 parallel tests for a workspace. |
| Region and data | Your own machine or CI region. | Provider regions and retention rules apply. Microsoft says Workspaces data is not stored or processed outside the deployed workspace region and that workspace data, run metadata, recordings and results are encrypted with Microsoft-managed keys. |
| Debugging | You control trace, video, screenshots and log retention. | May include hosted reports, recordings and traces; Microsoft’s page currently states 90-day report retention. |
Microsoft currently lists Workspaces regions including Australia East, East Asia, East US, Japan East, Switzerland North, West Europe and West US 3; another product page lists East US, West US 3, East Asia and West Europe. Treat region lists, concurrency and retention as dated service terms rather than permanent guarantees.
Make remote tests reliable
Wait for the right condition
Prefer locator assertions and explicit readiness signals over arbitrary sleeps. Use waitUntil: 'domcontentloaded' for navigation when you do not need every image, and wait for a selector or application state before clicking. Hosted latency makes race conditions more visible.
Control state and secrets
- Keep authentication state short-lived and encrypted.
- Set timeouts deliberately; a 30–90 second overall operation window is common for API clients, but choose values that match your pages.
- Redact authorization headers, cookies and tokens from traces and logs.
- Close contexts and sessions in a
finallyblock so abandoned browsers do not consume concurrency.
Capture useful artifacts
Enable traces, screenshots or video only where they help diagnose a failure; these artifacts increase storage and transfer. Record the provider, region, browser version, protocol and session ID alongside the test result so a remote failure can be reproduced.
Troubleshooting
“Browser executable doesn’t exist” locally
Run npx playwright install after installing or updating Playwright. In CI, cache the browser directory only when the cache key includes the Playwright version.
CDP connection is rejected
Check that the session is running, the endpoint has not expired, and the token is passed exactly as documented. Confirm that your client and provider agree on HTTPS/WebSocket formatting; do not substitute a normal website URL for a CDP endpoint.
A feature works locally but not remotely
Verify the provider’s protocol. A CDP endpoint may not implement Playwright-native features, and some services expose Chromium only. Switch to the provider’s native protocol or redesign the step using supported primitives.
Navigation times out
Check DNS and outbound access, then test the URL from the provider’s region. Wait for a stable selector instead of networkidle on pages with analytics or streaming requests. Capture a trace and inspect redirects, consent screens and bot challenges.
Tests interfere when run in parallel
Create a fresh context per test, isolate accounts and data, and cap workers below the provider’s concurrency limit. A cloud service can scale sessions, but it cannot make shared application state safe.
Or skip the browser setup
If your goal is a clean image or PDF rather than interactive Playwright assertions, ScreenshotNeo provides a one-request website screenshot API. It accepts consent banners before capture and removes more than 60 known consent platforms, newsletter popups and chat widgets; each step can be disabled. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and billing status.
Use the API directly (see the ScreenshotNeo documentation):
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpimport requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);ScreenshotNeo also offers an MCP server with take_screenshot, get_page_info and capture_pdf tools for Claude, Cursor and other MCP clients. Every plan includes its features; the free plan includes 1,000 shots per month with no card, and paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.
Frequently Asked Questions
Can I use Playwright with a cloud browser from CI?
Yes. Install the Playwright client in the CI job, create a provider session, connect using that provider’s documented protocol, and store credentials as CI secrets.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesDoes connecting over CDP support Firefox or WebKit?
Not necessarily. CDP is commonly used for Chromium; check the provider’s supported engines and use its native Playwright protocol when required.
Should every test run in the cloud?
No. Keep fast unit and smoke feedback local or on your own CI workers, and use hosted browsers when you need managed environments, parallel capacity, regional execution or hosted artifacts.
The Bottom Line
Prove the workflow with local Playwright first, then replace launch with the exact connection method your cloud provider supports. Treat protocol, browser-engine, region and retention details as provider-specific and subject to change.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
