Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsA cloud browser API lets your application control a real browser running on a provider’s infrastructure. Use a remote Playwright or Puppeteer connection over WebSocket/CDP when you need navigation, clicks, JavaScript, uploads, downloads, or multi-step state. Use REST or GraphQL when the job is a discrete task such as taking a screenshot, making a PDF, or extracting page content. The trade-off is straightforward: you manage less browser infrastructure, but you inherit the provider’s quotas, pricing, browser coverage, and session limits.
What remote browser automation means
In remote browser automation, your code runs on your own machine or application server while a browser runs elsewhere. Your code sends commands to that browser—open a URL, find an element, click it, wait for a result—and receives page data, files, or other outputs. The browser is remote; the logic that decides what to do can remain in your application.
A cloud browser API is the service interface to that managed browser or to a browser-powered task. Browserless describes managed headless browsers controlled with Puppeteer or Playwright over WebSocket, alongside REST and GraphQL APIs. Browserbase describes connecting existing Playwright scripts to cloud sessions with limited code changes. These products reduce the need to provision and maintain browser hosts, but do not remove the need to design, test, and monitor the automation itself.
Choose a connection pattern before choosing a provider
Playwright or Puppeteer over WebSocket
Use a browser-library connection for workflows that need ongoing control: navigating multiple pages, locating and interacting with elements, running JavaScript, handling a login flow, or managing state across steps. The client retains the familiar automation API while the browser process runs remotely. Browserless documents WebSocket connections for Puppeteer and Playwright; Browserbase’s quickstart demonstrates Playwright connecting over CDP.
#1 Best Overall
Playwright’s native protocol versus CDP
Playwright has two different connection methods. browserType.connect() attaches to a browser launched by a Playwright server using the Playwright protocol. browserType.connectOverCDP() attaches to an existing Chromium browser through a Chrome DevTools Protocol (CDP) HTTP or WebSocket endpoint. Playwright’s API reference describes CDP support as significantly lower fidelity than its own protocol and limits it to Chromium-based browsers. Prefer the native Playwright protocol when the remote service offers it and your workflow depends on advanced Playwright behavior; choose CDP when the service exposes a CDP endpoint or you specifically need to attach to an existing Chrome/Chromium browser.
REST or GraphQL task endpoints
Choose a task endpoint when the work is stateless and the output is well-defined. Browserless lists screenshot, PDF, scraping, search, crawl, and export APIs, as well as REST and GraphQL interfaces. This can be simpler than maintaining browser-library code for a one-off capture or extraction. It is less appropriate when your task depends on a sequence of custom UI interactions that must share browser state.
Selenium Grid
Selenium Grid remains relevant for teams already operating Selenium 4 hubs and nodes. Playwright also documents a Selenium Grid integration, but labels that integration experimental and documents a path limited to Google Chrome and Microsoft Edge. Treat it as a constrained integration, not a general guarantee that every Playwright browser and feature works through every Grid installation.
Connect Playwright to a remote Chromium browser
The example below uses Playwright’s CDP connection. It is runnable when CDP_ENDPOINT is set to the HTTP or WebSocket endpoint supplied by your cloud-browser provider and that endpoint accepts your session. Endpoint formats and authentication differ by service, so use the provider’s session or connection details rather than assuming one vendor’s URL pattern works with another.
- Install Node.js and Playwright: create a project, then run
npm install playwright. - Set the endpoint: provide the CDP endpoint as an environment variable. If your provider requires authentication, use the endpoint or connection configuration it documents; do not put credentials in source code.
- Run the script: it connects to the remote browser, opens a page, prints the title, and closes the remote browser connection.
remote-shot.js:
const { chromium } = require('playwright');
async function main() {
const endpoint = process.env.CDP_ENDPOINT;
if (!endpoint) throw new Error('Set CDP_ENDPOINT to your provider’s CDP endpoint');
const browser = await chromium.connectOverCDP(endpoint);
try {
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.title());
} finally {
await browser.close();
}
}
main().catch((error) => {
console.error(error);
process.exitCode = 1;
});Run it with CDP_ENDPOINT set in your shell or deployment environment. Use your provider’s documented cleanup behavior: closing a connection may end the session, or the provider may require a separate session-management call. The example does not create a provider session, because that step is service-specific.
If your provider supplies a native Playwright server endpoint instead, use chromium.connect(endpoint) in place of connectOverCDP(endpoint), with a compatible Playwright server endpoint. Do not interchange the two methods just because both endpoints use WebSocket: they speak different protocols.
How to choose among hosted browser services
Compare services against the requirements of your workflow, not just the name of the browser API. Browserless presents a managed fleet behind multiple interfaces, including Puppeteer, Playwright, REST, MCP, and BrowserQL. Its documentation lists session management, screenshot/PDF/scrape APIs, authenticated profiles, stealth features, and enterprise self-hosting. Browserbase focuses on cloud browser sessions for existing Playwright scripts; its documented capabilities include usage-based browser-hour pricing, autoscaling to hundreds of concurrent browsers, and session recording for replay.
| Option | Connection or control surface | Useful distinction | Watch for |
|---|---|---|---|
| Browserless | Puppeteer, Playwright, REST, GraphQL, MCP, and BrowserQL are described in its materials. | One managed fleet with browser-library connections and task APIs. | Plan quotas, unit consumption, concurrency, and which browser or endpoint is included in the tier you need. |
| Browserbase | Existing Playwright scripts connect to cloud sessions; the documented quickstart uses CDP. | Usage-based browser-hour billing, autoscaling, and session recording are described by the provider. | Confirm the session setup, supported connection mode, limits, and browser coverage for your actual use case. |
| Selenium Grid | Selenium 4 hub-and-node infrastructure; Playwright documents an experimental Grid integration. | Relevant when a team already operates Grid and wants to keep that infrastructure. | The documented Playwright integration is experimental and limited to Chrome and Edge. |
For Browserless, the pricing page lists regional endpoints in San Francisco, London, and Amsterdam on its free plan; it also lists Chrome, WebKit, and Firefox browser choices, persisted sessions, replays, and higher concurrency on paid tiers. Check the current plan details before relying on any one browser, region, or limit.
Browserless listed plan example
The Browserless pricing page lists the following plan figures. They are provider-published examples, not a permanent price quote; verify the live page and confirm whether the displayed billing term matches your intended purchase.
| Listed plan | Listed price and allowance | Concurrency detail stated |
|---|---|---|
| Free | $0/month; 1,000 units/month | Two maximum concurrent browsers |
| Prototyping | $25/month | Not stated here |
| Starter | $140/month when billed annually | Not stated here |
| Scale | $350/month when billed annually | Not stated here |
Browserless defines one unit as up to 30 seconds of browser time and lists additional-unit rates by plan. The exact additional-unit rates are not included here; check the current pricing page and estimate usage against your own session durations. A monthly unit allowance is not the same as a fixed number of pages: waits, page behavior, and session length can change how much browser time each job consumes.
A practical selection checklist
- Control surface: Decide whether you need Playwright’s native protocol, CDP, Puppeteer, REST, GraphQL, or a provider-specific interface such as BrowserQL.
- Browser coverage: Verify the actual availability of Chromium/Chrome, Firefox, and WebKit for the plan and connection type you will use. Do not infer one browser’s support from another.
- Scale and limits: Check maximum concurrency, session duration, queueing behavior, and what happens if a connection drops. These constraints can matter more than advertised peak autoscaling.
- State and debugging: Establish whether the service supports persistent profiles, cookies, reconnectable sessions, recordings, traces, or logs. Recording can aid replay, but assess what sensitive page content it may capture.
- Access reliability: Ask what proxy, CAPTCHA, stealth, and bot-detection controls are actually offered and permitted for your use case. A provider feature does not override a target site’s terms, access rules, or applicable law.
- Deployment and security: Compare provider-hosted and private deployment options, network boundaries, isolation, encryption, SSO, and compliance claims. Confirm the scope of any claim with the provider rather than assuming it applies to every plan.
- Total cost: Include usage units or browser hours, idle capacity, overages, regional egress, and support in the estimate. Test the expected number and duration of sessions against the provider’s billing definition.
Or skip the browser setup
If the deliverable is a screenshot or PDF—not a multi-step interactive browser session—you may not need a remote Playwright connection. ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. Its screenshot endpoint accepts one GET request and returns an image or PDF; it is a capture service, not a replacement for arbitrary browser-session control.
For example, this cURL request saves a WebP screenshot of Stripe. Create an API key and see the available parameters in the ScreenshotNeo API documentation.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo accepts cookie or consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each of those steps can be turned off. Bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed as clean shots, and response headers identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. The free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000. Sign up for 1,000 free screenshots a month with no card.
Troubleshooting remote browser sessions
Connection fails before a page opens
- Cause: The endpoint is missing, malformed, expired, or meant for a different protocol.
- Fix: Confirm whether the provider supplied a CDP endpoint or a native Playwright endpoint. Use
connectOverCDP()for CDP andconnect()for the Playwright protocol, and check that the session is still active.
Authentication or handshake errors
- Cause: The connection may require provider-specific credentials, headers, or session creation that the sample deliberately does not assume.
- Fix: Follow the provider’s connection instructions, keep keys out of source control, and verify that the endpoint and authentication belong to the same session.
Browser or API features behave differently than locally
- Cause: A CDP connection has lower Playwright fidelity than the native protocol, and cloud services may expose different browser builds, contexts, or limits.
- Fix: Test the workflow on the exact provider endpoint and browser you will deploy. If a Playwright feature is important, check whether the provider supports the native Playwright protocol for that plan.
Jobs slow down or queue
- Cause: The service may have reached its concurrency limit, be queueing sessions, or be spending time waiting on page resources and scripts.
- Fix: Inspect the plan’s concurrency and session rules, measure the duration of your own jobs, and reduce unnecessary navigation or waits. Do not assume a provider’s autoscaling statement guarantees immediate capacity under every account or plan.
Session closes or state disappears
- Cause: Temporary sessions may not persist automatically, and reconnect behavior differs by service.
- Fix: Check the provider’s session lifecycle and persistence features. Store only the state you need, and validate cookies or profiles in a test session before relying on them in a production workflow.
Performance, reliability, and cost in practice
A hosted browser can spare your team from operating browser workers, but it adds a network hop between your code and the page. Page load time still depends on the destination site, the browser’s work, and any waits your automation introduces. Measure full job duration, not just the time required to connect. Keep sessions no longer than necessary, and avoid opening more concurrent sessions than your plan supports.
For reliability, handle failures at the step where they occur: distinguish endpoint/session failures from navigation timeouts and missing page content. Give each task a bounded timeout, record enough non-sensitive context to diagnose errors, and make retries safe. A retry is not automatically harmless if the workflow submits a form, purchases an item, or otherwise changes remote state.
For cost, estimate the provider’s actual billing unit. Browserless’s unit definition is browser time up to 30 seconds per unit; Browserbase describes usage-based browser-hour billing. These models are not directly comparable without measuring representative session lengths and including concurrency, overages, and any other plan limits. For scheduled or bursty workloads, check whether sessions wait in a queue or consume usage while idle, then test with the expected pattern before committing to a plan.
FAQ
Does a hosted browser guarantee access to a site that blocks automation?
No. Services may describe stealth, proxy, or access features, but availability and results vary by provider, plan, target site, and the site’s own controls. Confirm permitted use and applicable site rules rather than treating a cloud browser as a way to bypass them.
When is a screenshot API enough instead of a cloud browser session?
Use a screenshot API when the required output is a capture or PDF and a single request fits the job. Use a remotely controlled browser when your application must carry out custom interactions or preserve state across steps.
Frequently Asked Questions
Does a hosted browser guarantee access to a site that blocks automation?
No. Services may describe stealth, proxy, or access features, but availability and results vary by provider, plan, target site, and the site’s own controls. Confirm permitted use and applicable site rules rather than treating a cloud browser as a way to bypass them.
When is a screenshot API enough instead of a cloud browser session?
Use a screenshot API when the required output is a capture or PDF and a single request fits the job. Use a remotely controlled browser when your application must carry out custom interactions or preserve state across steps.
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.
