[Blog](https://scrapfly.io/blog) / [cloud-browser](https://scrapfly.io/blog/tag/cloud-browser) / [7 Best Puppeteer Alternatives for Web Scraping in 2026](https://scrapfly.io/blog/posts/best-puppeteer-alternatives-for-web-scraping) # 7 Best Puppeteer Alternatives for Web Scraping in 2026 by [Mayada Shaaban](https://scrapfly.io/blog/author/mayada-shaaban-90143e67) Oct 14, 2026 23 min read [\#cloud-browser](https://scrapfly.io/blog/tag/cloud-browser) [\#headless-browser](https://scrapfly.io/blog/tag/headless-browser) [\#puppeteer](https://scrapfly.io/blog/tag/puppeteer) [ ](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fbest-puppeteer-alternatives-for-web-scraping "Share on LinkedIn") [ ](https://x.com/intent/tweet?url=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fbest-puppeteer-alternatives-for-web-scraping&text=7%20Best%20Puppeteer%20Alternatives%20for%20Web%20Scraping%20in%202026 "Share on X") [ ](https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fbest-puppeteer-alternatives-for-web-scraping "Share on Facebook") Summarize this article with [ ](https://chat.openai.com/?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fbest-puppeteer-alternatives-for-web-scraping) [ ](https://claude.ai/new?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fbest-puppeteer-alternatives-for-web-scraping) [ ](https://x.com/i/grok?text=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fbest-puppeteer-alternatives-for-web-scraping) [ ](https://www.perplexity.ai/search/new?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fbest-puppeteer-alternatives-for-web-scraping) [ ](https://www.google.com/search?udm=50&aep=11&q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fbest-puppeteer-alternatives-for-web-scraping) **Browser API**Automate browsers in the cloud with full JavaScript rendering support. [ Learn More ](https://scrapfly.io/products/cloud-browser-api) [ Docs ](https://scrapfly.io/docs/scrape-api/javascript-rendering) One of the key challenges with Puppeteer scrapers is blocking, and switching to Playwright is often the first fix we'd try. Unfortunately, in our test both libraries failed the same two automation checks on the same Chrome build, as `navigator.webdriver` was `true` and the user agent had `HeadlessChrome` in it. So which part of Puppeteer are we replacing? It can be the API we write scraper code against, the machine Chrome runs on or the browser itself. Below, we'll take a look at seven Puppeteer alternatives - four open-source projects and three Scrapfly APIs - and which of these parts each one replaces. ## Which Puppeteer Alternative Is Best? It depends on what's wrong with our Puppeteer scraper, so let's start with the packages we'll be testing. Here's the `package.json` we used: json ```json { "name": "puppeteer-alternatives-examples", "private": true, "type": "module", "dependencies": { "cheerio": "1.2.0", "crawlee": "3.18.2", "playwright": "1.63.0", "puppeteer": "25.12.0", "puppeteer-core": "25.12.0", "scrapfly-sdk": "0.12.0", "selenium-webdriver": "4.50.0" } } ``` Most of these are the alternatives themselves. For example, `playwright` is there for the library swap, as it's the closest thing to Puppeteer we'll test. We'll use `crawlee` to crawl several pages and `selenium-webdriver` for the WebDriver example. `cheerio` and `scrapfly-sdk` cover the pages where we don't run a browser ourselves, and `puppeteer-core` is what we'll connect to Cloud Browser with. That last one is where we'd start if our Puppeteer scraper keeps getting blocked! Note that `"type": "module"` lets us use `import` and top-level `await` in all of our examples. Most of them scrape the same page, [web-scraping.dev/product/1](https://web-scraping.dev/product/1), where the reviews only show up after JavaScript runs. ## 1. Scrapfly Cloud Browser API: Best for Keeping Your Puppeteer Code on Protected Sites Puppeteer works great for scraping javascript-heavy pages, though unfortunately when scraping at scale it's very likely we'll be blocked, as the headless Chrome it launches is easy to spot. Scrapfly Cloud Browser gets around this by running our Puppeteer code on Scrapium, Scrapfly's own Chromium fork, with a proxy attached to every session. To use it, we only need to change one line in our scraper! ### Setup Since the browser runs remotely, all we need is the `puppeteer-core` package without the bundled Chrome: shell ```shell npm install puppeteer-core ``` Rather than launching a browser, we'll be connecting to `wss://browser.scrapfly.io` and passing our session settings as URL parameters. For this example that's our `api_key`, the proxy pool and the `target_url`, which the [Puppeteer integration docs](https://scrapfly.io/docs/cloud-browser-api/puppeteer) recommend since routing is decided once the browser starts. Other options like the proxy `country` or browser `os` work the same way. ### Connecting Let's take a look at it in action by scraping reviews from our test product page: javascript ```javascript import puppeteer from 'puppeteer-core'; const params = new URLSearchParams({ api_key: process.env.SCRAPFLY_KEY, proxy_pool: 'datacenter', target_url: 'https://web-scraping.dev/product/1', }); // the only line that changes from a local script: connect() instead of launch() const browser = await puppeteer.connect({ browserWSEndpoint: `wss://browser.scrapfly.io?${params}` }); try { const page = await browser.newPage(); await page.goto('https://web-scraping.dev/product/1', { timeout: 60000 }); await page.waitForSelector('#reviews .review'); const reviews = await page.$$eval('#reviews .review', (els) => els.length); console.log('reviews:', reviews); console.log('navigator.webdriver:', await page.evaluate(() => navigator.webdriver)); console.log('browser:', await browser.version()); } finally { await browser.close(); // closing the browser ends the billed session } ``` Above, we're connecting to Scrapfly's browser rather than launching a local one, while the rest is the same Puppeteer code we'd use locally. We're also printing the `navigator.webdriver` variable, which is one of the variables websites check to detect automated browsers: text ```text reviews: 5 navigator.webdriver: false browser: Scrapium/154.0.8037.92 ``` All 5 reviews were scraped and `navigator.webdriver` is `false` - the automation flag is gone! We'll cover the automation detection test in greater detail in the [blocking section](#will-switching-from-puppeteer-stop-your-scraper-getting-blocked) below, where this same script had no detected checks against 2 for local Puppeteer. You might also notice that our code closes the browser in a `finally` block. [Cloud Browser](https://scrapfly.io/products/cloud-browser-api) is billed per minute of browser time plus bandwidth, so we always want to close our sessions once we're done (failed connections and crashed sessions are free). ### Sessions and Other Features For scraping websites that require a login, we can reuse the same browser across multiple connections. For this, we pass a `session` ID together with `auto_close=false`, and the browser keeps its cookies and storage between connections (see [Session Resume](https://scrapfly.io/docs/cloud-browser-api/session-resume)). There are a few other useful parameters too: - `solve_captcha=true` - enables the built-in captcha solver, billed per solve (failed attempts are free) - `block_images` and `block_fonts` - stub out heavy resources to save bandwidth Finally, if we ever decide to switch to Playwright, the same browser can be used through `chromium.connectOverCDP()`. [Web Scraping with Playwright and JavaScriptLearn about Playwright - a browser automation toolkit for server side Javascript like NodeJS, Deno or Bun.](https://scrapfly.io/blog/posts/web-scraping-with-playwright-and-javascript) ### Limitations So what's the catch? The first one is that `connect()` doesn't take launch arguments, so Chrome flags like `--window-size` or `--no-sandbox` won't do anything here. The second is `page.on('console')`, which doesn't receive any output from page scripts because of the stealth patches. Scrapium is Chromium only, so there's no Firefox here. How long can a session last? 15 minutes by default, or up to 30 with the `timeout` parameter. ## 2. Playwright: Best for a Multi-Engine Rewrite Across Chromium, Firefox and WebKit Playwright is a browser automation library from Microsoft, and it's the closest thing to a drop-in replacement for Puppeteer. That's no accident, as its team described itself as "the same team that originally built Puppeteer at Google" when Playwright came out in January 2020 ([InfoQ](https://www.infoq.com/news/2020/01/playwright-browser-automation/), January 30, 2020). So what do we gain by switching? Mainly auto-waiting locators, which we'll see in a moment, and the WebKit engine, as Puppeteer already drives both Chrome and Firefox (through WebDriver BiDi). Unlike Puppeteer, Playwright also has official versions for Python, Java and .NET. Since the APIs are so similar, most Puppeteer calls have a direct counterpart in Playwright: | Puppeteer | Playwright | |---|---| | `puppeteer.launch()` | `chromium.launch()` | | `waitForSelector()` then `$$eval()` | `locator().first().waitFor()` then `allTextContents()` | | `browser.createBrowserContext()` | `browser.newContext()` | | `puppeteer.connect()` | `chromium.connectOverCDP()` | To see the difference, let's port our review scraper: javascript ```javascript import { chromium } from 'playwright'; const browser = await chromium.launch(); try { const page = await browser.newPage(); await page.goto('https://web-scraping.dev/product/1'); // the locator re-queries the page and waits for a match on its own const reviews = page.locator('#reviews .review'); await reviews.first().waitFor(); console.log('reviews:', await reviews.count()); console.log('first:', await reviews.first().locator('p').textContent()); } finally { await browser.close(); } ``` Above, we're using a locator rather than `waitForSelector()`. Locators re-query the page every time we use them, and methods like `textContent()` wait for a match by themselves. `count()` doesn't, which is why we wait on `first()` before counting: text ```text reviews: 5 first: Absolutely delicious! The orange flavor is my favorite. ``` All 5 reviews were found with Playwright 1.63.0 and its bundled Chromium, without a single `waitForSelector()` call! So does Playwright help with blocking? Unfortunately not, as on the same Chrome build it tripped the same two automation checks as Puppeteer. Playwright also uses its own browser builds, which we download with `npx playwright install`. Its Firefox [relies on patches](https://playwright.dev/docs/browsers), so it won't work with the regular Firefox we'd install ourselves. For remote browsers, `connectOverCDP()` only works with Chromium, and the [BrowserType reference](https://playwright.dev/docs/api/class-browsertype) calls it "significantly lower fidelity" than Playwright's own protocol. Meaning, we can connect to a remote stealth Chromium like Cloud Browser, but not to a remote Firefox or WebKit. For a feature-by-feature comparison, see [Puppeteer vs Playwright](https://scrapfly.io/blog/posts/puppeteer-vs-playwright), and for a full build, [Web Scraping with Playwright and JavaScript](https://scrapfly.io/blog/posts/web-scraping-with-playwright-and-javascript). ## 3. Scrapfly Web Scraping API: Best for Rendered Pages Without Running a Browser Often our Puppeteer scrapers only use the browser to render the page - we go to a URL, wait for an element to load and read the HTML. In this case, we don't need to run the browser ourselves at all, as the [Scrapfly Web Scraping API](https://scrapfly.io/products/web-scraping-api) can render the page for us and return the final HTML (or even Markdown). Using it, there's no browser to launch, patch or scale - we just send a request and get the page back! Scrapfly has SDKs for Python, TypeScript, Go and Rust. For our Node.js example, let's install the [TypeScript SDK](https://scrapfly.io/docs/sdk/typescript): shell ```shell npm install scrapfly-sdk ``` Now, let's scrape our product page reviews again, this time without Puppeteer: javascript ```javascript import { ScrapflyClient, ScrapeConfig } from 'scrapfly-sdk'; const client = new ScrapflyClient({ key: process.env.SCRAPFLY_KEY }); const result = await client.scrape( new ScrapeConfig({ url: 'https://web-scraping.dev/product/1', render_js: true, // render the page in a cloud browser wait_for_selector: '#reviews .review', // the same wait as page.waitForSelector() // unblocker: true, // anti-bot bypass for protected sites (asp is the older alias) }), ); console.log('status:', result.result.status_code); console.log('reviews:', result.selector('#reviews .review').length); console.log('credits:', result.context.cost.total); ``` Here, we're creating a Scrapfly client with our API key and sending a scrape request for our product page. Once the page is back, we can parse it right away with `result.selector()` using the same CSS selectors: text ```text status: 200 reviews: 5 credits: 6 ``` We got all 5 reviews from a single API call! So, how do we interact with the page, like clicking buttons or scrolling? For this, the API has [JavaScript scenarios](https://scrapfly.io/docs/scrape-api/javascript-scenario) (`js_scenario`), which let us define a list of browser actions like clicks, text input and scrolling that run before the page is returned. There are a few other useful options too: - `format` - return the page as `markdown`, `clean_html` or `text` (our page came back as 4,563 characters of Markdown) - `unblocker` - Unblocker (previously ASP), Scrapfly's anti-bot bypass for protected websites - `country` - the proxy country for geo-targeting Failed scrapes aren't billed, so if the Unblocker can't get through or the target website errors out, we don't pay for it. Unfortunately, a `js_scenario` only has 25 seconds to run, so for logins and longer flows we'd use Cloud Browser instead. Rendering took 5 of our 6 credits too, so we only turn `render_js` on when a page needs it. ## 4. Crawlee: Best for Multi-Page Crawls Around Your Puppeteer Code The product listing on web-scraping.dev is split into several pages, with links to the next ones on each page. To scrape all of them, our Puppeteer script would have to follow those links and keep track of the pages it has already seen, so it doesn't scrape the same one twice. If a page fails we'd want to retry it, and with more pages we'd want to run a few at once and save the results somewhere. Crawlee does all of that for us, so our code only has to scrape each page with plain Puppeteer! Crawlee isn't limited to Puppeteer either, as `PlaywrightCrawler` and `CheerioCrawler` work the same way as `PuppeteerCrawler`. Switching to `PlaywrightCrawler` keeps this handler as it is, but `CheerioCrawler` passes `$` in place of a browser `page`, so its handler needs rewriting. To start, we'll need Crawlee itself and Puppeteer: shell ```shell npm install crawlee puppeteer ``` Now, let's write a crawler that scrapes the paginated product listing on web-scraping.dev: javascript ```javascript import { PuppeteerCrawler, Dataset } from 'crawlee'; const crawler = new PuppeteerCrawler({ maxRequestsPerCrawl: 3, async requestHandler({ request, page, enqueueLinks }) { // the same page code you would write in a plain Puppeteer script const products = await page.$$eval('.products .product', (els) => els.map((el) => ({ title: el.querySelector('h3 a').textContent.trim(), price: el.querySelector('.price').textContent.trim(), })), ); await Dataset.pushData({ url: request.url, products }); // queue the pagination links; the queue skips URLs it has already seen await enqueueLinks({ selector: '.paging a' }); }, }); await crawler.run(['https://web-scraping.dev/products?page=1']); const { items } = await Dataset.getData(); for (const row of items) console.log(row.url, row.products.length, row.products[0].title); ``` Above, we defined our crawler which: - opens each page in Puppeteer and passes it to our `requestHandler` - scrapes product titles and prices with the usual `$$eval` call - saves each page's products to Crawlee's `Dataset` storage - finds pagination links with `enqueueLinks()` and adds them to the queue, skipping URLs it has already seen - stops after 3 requests through `maxRequestsPerCrawl` Running it, we get one row for each listing page: text ```text https://web-scraping.dev/products?page=1 5 Box of Chocolate Candy https://web-scraping.dev/products?page=3 5 Classic Leather Sneakers https://web-scraping.dev/products?page=2 5 Dragon Energy Potion ``` Notice that the pages finish out of order, as Crawlee scrapes them concurrently - and all 3 succeeded! There's one thing to watch out for, though. If we start from `/products` and not `/products?page=1`, Crawlee sees them as separate URLs and the first page gets scraped twice. So, we should always start from the full first page URL, or normalize links before they're queued. Crawlee is open source (Apache-2.0) and maintained by Apify, though it runs locally without an Apify account. It's also available for Python! Unfortunately, Crawlee doesn't run the browsers for us. We still need to keep them updated and bring our own fingerprints and proxies for protected websites, and for a single page it's more setup than a plain Puppeteer script. For more, see the [Crawlee quick start](https://crawlee.dev/js/docs/quick-start), which covers the other crawler classes. ## 5. Cheerio: Best When the Data Is Already in the HTML Not every page that looks dynamic needs a browser. A lot of websites send their data together with the HTML and only use JavaScript to display it, which means we can skip Puppeteer and parse the page source directly with Cheerio. Cheerio is an HTML parser for Node.js with jQuery-style selectors. It doesn't run JavaScript or render anything, so there's no browser to install at all! So, how do we know if a page needs a browser? Before reaching for Puppeteer, we can check a few things: - the page source (not the rendered page) - does it contain the text we need? - hidden JSON - is the data stored in a `