Puppeteer Undetected Fingerprint Browser With Scrapeless

TL;DR:

• Puppeteer already speaks the Chrome DevTools Protocol, so puppeteer.connect() points it at Scrapeless with one URL. Swap a local puppeteer.launch() for a connection to the cloud browser and every script runs on a clean identity.
• A local Puppeteer 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 Puppeteer code is unchanged. page.goto, page.evaluate, selectors, and waits behave exactly as they do locally; only the connection line moves.
• Verified live: a puppeteer.connect() session read navigator.webdriver as false, reported a US residential exit IP, and returned the target page's real title.
• Free to start. New Scrapeless accounts include free Scraping Browser runtime — sign up at app.scrapeless.com.

Introduction: connect Puppeteer to a browser that reads clean

Puppeteer drives a real Chromium over the DevTools Protocol. Launch that 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 with a stealth plugin and then keep patching as Chromium and the detectors move. There is a shorter path. Puppeteer connects to any browser exposing a DevTools endpoint through puppeteer.connect(), and the Scrapeless Scraping Browser is a Chrome DevTools Protocol endpoint reached over one WebSocket URL. Point Puppeteer 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 — page.evaluate, selectors, clicks, and waits 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 Puppeteer 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
• puppeteer-core installed (no bundled Chromium 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 puppeteer-core — it ships without a local Chromium download, since the browser lives in the cloud.

npm install puppeteer-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 puppeteer.launch() with puppeteer.connect() and hand it the endpoint. Everything after that is standard Puppeteer.

import puppeteer from "puppeteer-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 puppeteer.connect({ browserWSEndpoint: 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 page.goto("https://httpbin.io/ip", { waitUntil: "domcontentloaded", timeout: 60000 });
console.log("exit ip:", JSON.parse(await page.evaluate(() => document.body.innerText)).origin);

await browser.close();

A live run of this script printed the page title Effortless Web Scraping Toolkit - Scrapeless, navigator.webdriver: false, and a US residential exit IP — the same Puppeteer 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 Puppeteer stops

Running Puppeteer 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 page calls stay identical.

What you get back

The session behaves like any Puppeteer session — page.goto, page.evaluate, page.$$eval, 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.
• sessionTTL is in seconds here — set it long enough to cover the full flow; the session closes when it lapses.
• 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 Puppeteer, cleaner browser

Puppeteer decides what to do; Scrapeless decides how the browser looks to the site. The integration is one line — puppeteer.connect() 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 Puppeteer Scraping Pipeline?

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

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

FAQ

Q: Do I have to change my Puppeteer code?
No. You change how the browser is obtained — puppeteer.connect({ browserWSEndpoint }) instead of puppeteer.launch(). Every page call after that is identical.

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

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 sessionTTL in seconds or milliseconds?
For the Scraping Browser connection here it is seconds — 180 is three minutes. Set it to cover the whole flow.

Q: Is web scraping with Puppeteer 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.