Skip to main content
Playwright Cloud

Run Playwright Without Maintaining Browser Infrastructure

Change your connection URL and your existing Playwright suite runs on managed browsers. Chromium, Chrome, Firefox, WebKit, and Edge are all reachable from the same API token.

Start For FreeRead the docs
Keep your existing tests
Your page objects, fixtures, and assertions stay exactly as they are. Nothing about your test code changes.
Swap the connection URL
Replace your local browser launch with connectOverCDP or connect against a Browserless endpoint and your token.
We run the browsers
Browser patching, memory pressure, and capacity planning move to us. You get a pool that is already warm.

Five engines, one endpoint

Playwright is the only library that reaches every browser Browserless runs. Firefox, WebKit, and Edge are available through Playwright's native protocol and cannot be driven with Puppeteer.

Chromium

connectOverCDP
/chromium
connect
/chromium/playwright
Stealth
Available

Default. Recommended for most automation.

Chrome

connectOverCDP
/chrome
connect
/chrome/playwright
Stealth
Available

Proprietary codecs for streaming and DRM sites.

Firefox

connectOverCDP
Not supported
connect
/firefox/playwright
Stealth
Not available

Gecko engine. Playwright reaches it, Puppeteer cannot.

WebKit

connectOverCDP
Not supported
connect
/webkit/playwright
Stealth
Not available

Safari engine, for iOS and mobile web checks.

Edge

connectOverCDP
Not supported
connect
/edge/playwright
Stealth
Not available

Chromium-based Edge for Microsoft-stack testing.

Two ways to connect

connectOverCDP is the recommended default and tolerates version drift between your client and our workers. Native connect is version-coupled but required for Firefox, WebKit, and Edge.

connectOverCDP (recommended)
Chromium over the DevTools Protocol. Forgiving about client version.
import { chromium } from 'playwright-core';

const browser = await chromium.connectOverCDP(
  'wss://production-sfo.browserless.io?token=YOUR_API_TOKEN'
);

const context = await browser.newContext();
const page = await context.newPage();
await page.goto('https://example.com');
console.log(await page.title());

await browser.close();
Native connect for Firefox and WebKit
Required for non-Chromium engines and for page.route interception.
import { firefox } from 'playwright-core';

const browser = await firefox.connect(
  'wss://production-sfo.browserless.io/firefox/playwright?token=YOUR_API_TOKEN'
);

const page = await browser.newPage();
await page.goto('https://example.com');

await browser.close();
Python
The same endpoint, driven from the sync API.
from playwright.sync_api import sync_playwright

TOKEN = "YOUR_API_TOKEN"

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(
        f"wss://production-sfo.browserless.io?token={TOKEN}"
    )
    context = browser.new_context()
    page = context.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()
Reuse a session across requests
Create a session with a TTL, then connect to it more than once.
// Create a session that outlives a single connection
const res = await fetch(
  'https://production-sfo.browserless.io/session?token=YOUR_API_TOKEN',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ ttl: 60000 }),
  }
);

const { connect } = await res.json();

// Connect now, then reconnect later to the same persisted session
const browser = await chromium.connectOverCDP(connect);

What you get on the managed fleet

Cross-engine coverage
Run the same spec against Chromium, Firefox, and WebKit to catch engine-specific regressions before users do.
Three regions
Connect to San Francisco, London, or Amsterdam by changing the hostname, so your sessions start close to the sites you are hitting.
Version mismatches, handled
Workers track recent Playwright releases. Pin your client to a supported version, or use connectOverCDP and stop worrying about the coupling entirely.
Persistent sessions
Create a session with a TTL through the Session API and reconnect to the same persisted session across runs.
Queueing built in
Requests beyond your concurrency limit queue rather than fail, up to twice your plan's concurrent allowance.
Cloud or self-hosted
Run on our fleet, or take the same APIs into your own Docker deployment when data residency requires it.

The hard part is never the script

"The implementation is probably fine. It's the management of the session, making sure it's fault-tolerant. Those other pieces that are more like ops and DevOps and infrastructure. Those are the harder ones. And everything keeps changing. Browsers need to be updated to the new version of Chrome. All that stuff. It's a cat-and-mouse game."

Cyrus Ghazanfar

Co-founder & CTO, Beagle

Read the Beagle case study

Point your Playwright suite at Browserless

The free plan includes 1,000 units, enough to run a real suite before you decide.

See pricing