Playwright Undetected Fingerprint Browser With Scrapeless

TL;DR:

• Playwright connects to any CDP browser with chromium.connectOverCDP(), so pointing it at Scrapeless is one URL. Swap a local chromium.launch() for a connection to the cloud browser and every script runs on a clean identity.
• A local Playwright browser leaks automation on three axes: the navigator.webdriver flag, a headless-default fingerprint, and your own exit IP. Anti-bot systems score all three together.
• The Scrapeless Scraping Browser answers all three server-side — real self-developed Chromium, a consistent per-session fingerprint with no webdriver tell, and residential egress in 195+ countries.
• Your Playwright code is unchanged. page.goto, page.locator, page.evaluate, and waits behave exactly as they do locally; only the connection line moves.
• Verified live: a connectOverCDP() session read navigator.webdriver as false and returned the target page's real title through the Scrapeless cloud browser.
• Free to start. New Scrapeless accounts include free Scraping Browser runtime — sign up at app.scrapeless.com.

Introduction: connect Playwright to a browser that reads clean

Playwright drives Chromium, Firefox, or WebKit through a single API. Launch Chromium on your own machine and every script inherits the signals that make automation obvious: it announces itself through the navigator.webdriver property, ships headless-default fonts and canvas behavior, and exits from an IP that reputation services already recognize.

You can patch each of those by hand and then keep patching as Chromium and the detectors move. There is a shorter path. Playwright attaches to any browser exposing a DevTools endpoint through chromium.connectOverCDP(), and the Scrapeless Scraping Browser is a Chrome DevTools Protocol endpoint reached over one WebSocket URL. Point Playwright at it and the fingerprint, behavioral surface, and exit IP move server-side — your script stays where it is.

What you can do with it

• Run scripts against anti-bot-protected sites — the cloud browser clears challenges during render, so page.goto reaches content.
• Localize the session — pin proxyCountry so a page resolves the way a visitor in that market sees it.
• Send a consistent fingerprint — pass a fingerprint object so user agent, platform, screen, and timezone stay coherent.
• Persist login state — carry a profileId so cookies and local storage survive between runs.
• Scale past your machine — sessions run in the cloud, not on your laptop.
• Keep the automation identical — locators, page.evaluate, clicks, and auto-waiting are unchanged.

Why Scrapeless Scraping Browser

The Scrapeless Scraping Browser is a customizable, anti-detection cloud browser designed for web crawlers and AI agents. For Playwright specifically, it brings:

• Real self-developed Chromium that runs page JavaScript exactly like Chrome, so SPAs and challenges resolve.
• A consistent per-session fingerprint — no navigator.webdriver tell, no headless defaults leaking through.
• Residential egress in 195+ countries, selected per session with one proxyCountry value.
• Session persistence through profileId, so an authenticated flow keeps its state.
• One connection surface — every option is a query parameter on the same WebSocket endpoint.

Get your API key on the free plan at app.scrapeless.com.

Prerequisites

• Node.js 18 or newer
• playwright-core installed (no bundled browsers needed — you connect to a remote one)
• A Scrapeless account and API key — sign up at app.scrapeless.com

Full connection details live in the Scraping Browser documentation.

Install

Use playwright-core — it skips the browser download, since Chromium lives in the cloud.

npm install playwright-core
export SCRAPELESS_API_KEY=your_api_token_here   # free key at https://app.scrapeless.com

Configure the connection

The endpoint is wss://browser.scrapeless.com/api/v2/browser, and every option is a query parameter. Pin proxyCountry to a residential region.

import { URLSearchParams } from "node:url";

function scrapelessEndpoint(extra = {}) {
  const params = new URLSearchParams({
    token: process.env.SCRAPELESS_API_KEY,
    sessionTTL: "180",       // seconds
    proxyCountry: "US",
    ...extra,
  });
  return `wss://browser.scrapeless.com/api/v2/browser?${params}`;
}

Connect and run

Replace chromium.launch() with chromium.connectOverCDP() and hand it the endpoint. Everything after that is standard Playwright.

import { chromium } from "playwright-core";
import { URLSearchParams } from "node:url";

const params = new URLSearchParams({
  token: process.env.SCRAPELESS_API_KEY,
  sessionTTL: "180",
  proxyCountry: "US",
});
const endpoint = `wss://browser.scrapeless.com/api/v2/browser?${params}`;

const browser = await chromium.connectOverCDP(endpoint);
const page = await browser.newPage();

await page.goto("https://www.scrapeless.com/en", { waitUntil: "domcontentloaded", timeout: 60000 });
console.log("title:", await page.title());
console.log("navigator.webdriver:", await page.evaluate(() => navigator.webdriver));

await browser.close();

A live run of this script printed the page title Effortless Web Scraping Toolkit - Scrapeless and navigator.webdriver: false — the same Playwright API you already use, sourced through the cloud browser.

Get your API key on the free plan: app.scrapeless.com

Send a consistent fingerprint

A fingerprint object keeps the browser's advertised identity coherent — user agent, platform, screen, and timezone all agree. JSON-encode it, URL-encode it, and pass it as one more parameter. The W3C WebDriver specification requires conforming automation to expose the webdriver flag; the cloud browser does not carry it, so nothing contradicts the fingerprint you send.

const fingerprint = {
  userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
  platform: "Windows",
  screen: { width: 1920, height: 1080 },
  localization: { languages: ["en-US", "en"], timezone: "America/New_York" },
};
const endpoint = scrapelessEndpoint({ fingerprint: encodeURIComponent(JSON.stringify(fingerprint)) });

Where local Playwright stops

Running Playwright on your own Chromium is fine for open, unprotected pages. The friction starts where the target scores the browser: a challenge interstitial that stalls on a datacenter IP, a page that fingerprints the headless defaults, or a login wall that wants a stable identity across visits. Each is a fingerprint, behavior, or IP problem — exactly the three the cloud browser handles server-side. Connecting to Scrapeless hands those cases to a managed session while your locators and page calls stay identical.

What you get back

The session behaves like any Playwright session — locators, page.goto, page.evaluate, auto-waiting, and cookies all work. A few honest observations from running it over the cloud browser:

• navigator.webdriver is false, so the first check a site runs reads like a real Chrome.
• connectOverCDP returns a normal Browser — newPage, contexts, and locators are unchanged.
• The exit IP matches proxyCountry — geo-gated pages resolve as a local visitor sees them.
• Warm the session for stubborn pages — load the site's homepage first before the protected page, so the behavioral surface reads like a normal visit.

Conclusion: same Playwright, cleaner browser

Playwright decides what to do; Scrapeless decides how the browser looks to the site. The integration is one line — chromium.connectOverCDP() against the cloud browser — and the rest of your script is untouched. Pin proxyCountry to a residential region, pass a coherent fingerprint, and reuse a profileId for authenticated flows. For running the same cloud browser from Python instead, see the Scrapling production-scraper guide, and compare plans on the Scrapeless pricing page.

Ready to Build Your Playwright Scraping Pipeline?

Join our community to claim a free plan and connect with developers building Playwright pipelines: Discord · Telegram.

Sign up at app.scrapeless.com for free Scraping Browser runtime and point connectOverCDP() at the cloud browser your targets can't fingerprint.

FAQ

Q: Do I have to change my Playwright code?
No. You change how the browser is obtained — chromium.connectOverCDP(endpoint) instead of chromium.launch(). Every locator and page call after that is identical.

Q: playwright or playwright-core?
Use playwright-core. It skips the browser download because you connect to the cloud browser instead of launching a local one.

Q: Does connectOverCDP support all three browser engines?
The CDP connection is Chromium-based, which is what the Scrapeless cloud browser exposes. Point chromium.connectOverCDP() at the endpoint; your Chromium-targeted scripts run unchanged.

Q: Do I need a proxy?
No. Residential egress is built in — set proxyCountry to a region or ANY. There is no separate proxy to wire up.

Q: Is web scraping with Playwright legal?
Accessing publicly available data is generally permitted, but the rules vary by jurisdiction and site. Review the target's terms of service, respect robots directives, and consult counsel for anything sensitive.