Playwright vs Puppeteer vs Selenium for Web Scraping (2026)

By Rajesh Kannan, Co-Founder & CTO, Gramosoft · Last updated: November 5, 2026 · Lab results from our own side-by-side test on November 5, 2026 (Playwright 1.64, Puppeteer 25.16, Selenium 4.52, Chromium 141)

Playwright, Puppeteer and Selenium all drive a real browser, so all three can scrape pages that build their content in JavaScript. They differ in protocol, browser and language coverage, how they wait for elements, and what they cost to run. This comparison covers each difference, what our side-by-side lab measured, and when GcrawlAI is the simpler route.

Playwright vs Puppeteer vs Selenium at a glance

Rendered pages without running any of them: GcrawlAI

Whichever library you pick, you still run the browser: installing it, matching versions, sizing memory and restarting crashed sessions. That's fine for some teams. If what you need is the rendered page, GcrawlAI runs a real browser on its side and returns HTML or Markdown, with no library, driver or browser on your servers.

The homepage puts it in one line: JavaScript rendering, anti-bot stealth and proxies come with every request, with no credit system. A page you'd load with Playwright, Puppeteer or Selenium arrives from one API call instead, and the browser binaries, driver versions and memory limits stay off your side.

Here's the practice page our Playwright example uses, fetched through GcrawlAI and kept only if the books are in it:

# pip install gcrawl-sdk parsel
"""The same page through GcrawlAI: the browser runs on GcrawlAI's side, so there is no Playwright,
Puppeteer or Selenium install, no driver and no browser to update. Keep the page only if the books are in it."""
import os

from gcrawl_sdk import GcrawlClient, ScrapeOptions
from parsel import Selector

gc = GcrawlClient(api_key=os.getenv("GCRAWL_API_KEY", "gc-YOUR_API_KEY"))

page = gc.scrape(url="https://books.toscrape.com/",
                 options=ScrapeOptions(html_enabled=True, markdown_enabled=True, proxy_geo="US"), wait=True)
books = Selector(page.html or "").css("article.product_pod")
print(f"{len(books)} books" if books else "page came back without books: check before storing")

• Rendering and access: a real browser through residential IPs in the country you choose, with retries and stealth escalation inside the request.
• Output you can check: HTML, Markdown or JSON, plus extractors that return structured fields for common page types.
• Scrape, crawl, screenshots and Search API: scrape single pages, crawl whole sites, capture screenshots, or use the Search API.
• For developers and AI agents: a Python SDK, an MCP server for Claude, Cursor and other agents, the Playground to test a page before you write code, and the docs.

The MIT-licensed core also runs on your own servers: clone it from GitHub and the setup script in the code download starts the API with Redis and a Celery worker.

Pricing is a free plan of 50 requests a month with no card, paid plans from $0.67 to $1.45 per 1,000 requests, and a self-hosted core that costs nothing. Failed requests are never charged. The full plan table is in the cost section.

Where it falls short: you don't get a live browser session you can script step by step, and no service reaches every page, GcrawlAI included. Test your own targets on the free plan. It won't solve CAPTCHAs meant for humans or log in for you, and it doesn't make collecting a site's data acceptable when that site's terms say no.

"Teams spend weeks choosing between Playwright, Puppeteer and Selenium, then discover the library was the easy part. The browser fleet is where the time goes."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

How each tool talks to the browser

The protocol explains most of the other differences. Selenium sends each command over HTTP to a driver process, which then controls the browser. Puppeteer and Playwright keep one persistent connection to the browser itself. That's why Selenium reaches more browsers, and why the other two are quicker per command.

• Selenium: the W3C WebDriver standard, a W3C Recommendation since 2018, according to Browser Use. Any browser with a driver gets Selenium support, and Selenium now also speaks WebDriver BiDi for events such as network and log messages.
• Puppeteer: the Chrome DevTools Protocol (CDP) by default, and WebDriver BiDi for Firefox. Browserless notes Firefox support became official in Puppeteer 23, while Chrome is where the library is most mature.
• Playwright: CDP for Chromium and its own protocols for Firefox and WebKit, which is how one API covers three engines. In Python, Java and .NET it runs a bundled Node.js driver process between your code and the browser, as Ivinco points out.

Network control follows the protocol. CrawlerBros notes that Playwright and Puppeteer can intercept requests directly, which helps you find the JSON endpoint behind a page, while Selenium's interception is limited and depends on the driver.

Browsers and languages

Coverage decides the choice for many teams before speed does. Playwright covers three rendering engines, Selenium drives the real Safari application, and Puppeteer is Chrome-first with Firefox support. For languages, Selenium reaches furthest, Playwright covers the four most common, and Puppeteer is officially JavaScript and TypeScript only.

For scraping, language usually matters most. Ivinco cites the Apify and Web Scraping Club survey, where 71.7% of respondents use Python and 17% JavaScript. That leaves Puppeteer out for most scraping teams unless they already run Node.js.

Waiting: where scrapers get flaky

Most broken browser scrapers fail on timing, not selectors. Playwright waits for an element to be ready before acting on it. Puppeteer's locators wait too, but its lower-level calls leave waiting to you. Selenium expects explicit waits. Each works; the difference is how much waiting code you write and review.

• Playwright: a click waits for the target to be visible, stable, enabled and able to receive events. Browser Use adds a caution: reading text doesn't wait for the page's final state, so wait for the element you need first.
• Puppeteer: locator actions check visibility, enabled state and a stable position; waitForSelector() and other lower-level calls need you to say what to wait for.
• Selenium: WebDriverWait with expected conditions. It's explicit and flexible, and our lab showed one side effect: it polls every 0.5 seconds by default, so an element that appears at 1.2 seconds is seen at about 1.5.

The rule is the same in all three, as CrawlerBros puts it: wait for a fact, such as an element, a response or a URL, not a fixed number of seconds.

A first scrape with Playwright

Because Playwright is the default recommendation, here's what a basic scrape looks like in Python. It opens Books to Scrape, a public site built for scraping practice, waits for the product cards, reads each title and price, and stops if nothing came back. We ran it against a local copy of the page.

# pip install playwright && playwright install chromium
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()            # headless by default
    page = browser.new_page()
    page.goto("https://books.toscrape.com/")

    cards = page.locator("article.product_pod")
    cards.first.wait_for()                   # auto-wait; raises TimeoutError if nothing appears

    books = [(card.locator("h3 a").get_attribute("title"),
              card.locator("p.price_color").inner_text())
             for card in cards.all()]
    browser.close()

if not books:
    raise SystemExit("page loaded without books: check before storing")
for title, price in books:
    print(f"{price}  {title}")

• Install: pip install playwright, then playwright install chromium to download only the browser you need rather than all three.
• Async: from playwright.async_api import async_playwright gives the same API for running many pages concurrently.
• Puppeteer and Selenium versions: the same job in both is in the code download, alongside the lab scripts that timed all three.

What our side-by-side lab measured

Published benchmarks for these three tools disagree with each other, so we ran our own. On November 5, 2026, each tool drove the same Chromium 141, headless, against the same local four-page site, five times. We report medians. No third-party sites were involved, so this measures the tools, not anti-bot results.

• Per command, the protocol shows: Selenium's 9 ms per read is roughly 3.5 to 9 times the CDP tools. Our Selenium extraction made 41 WebDriver calls for 20 cards, which is why it took 0.85 s. Reading everything in one execute_script call would narrow that gap.
• Per page, it barely matters: walking four pages took 0.22 to 0.30 s in all four, because the browser does the same work underneath.
• Memory is mostly the browser: 292 to 326 MB in every case. The surprise was Playwright for Python, whose Node driver process added 169 MB. Playwright for Node had no extra process.
• Setup friction: Selenium needs a driver that matches the browser's major version. A chromedriver 147 refused our Chromium 141 with SessionNotCreatedException; a matching 141 driver worked.

Compare that with published figures: AlterLab lists about 40 MB per Playwright session and 150 MB for Selenium, while a DEV Community benchmark lists 280 MB and 420 MB. Pages, contexts and machines differ, so measure on your own targets before sizing servers.

"The 169 MB Node driver behind Playwright's Python API surprised our team. It doesn't matter for one browser. At a hundred concurrent workers, it's a server you didn't budget for."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

Running them at scale, and detection

Once scrapers leave a laptop, the library matters less than the browser infrastructure behind it. Chrome uses memory over long runs, concurrent sessions compete for CPU and shared memory, and browser versions need patching. Detection is the other constant: none of the three is undetectable out of the box.

• Concurrency: Playwright and Puppeteer run many isolated browser contexts in one browser. Selenium's Python API is synchronous, so concurrency means threads, processes or Selenium Grid, which Ivinco notes is still the strongest built-in way to rotate Chrome, Firefox and Edge.
• Crawler integration: Scrapy pairs with Playwright through scrapy-playwright. ByteTunnels recommends Scrapy for static pages with Playwright rendering only the pages that need it. Ivinco notes scrapy-selenium's last release was in 2019.
• Managed browsers: Browserless says its version 2 dropped Selenium and WebDriver support, so on that service only Playwright and Puppeteer connect.
• Detection: stock sessions expose signals such as navigator.webdriver, and ChromeDriver adds its own. Ivinco notes the well-known stealth plugins for Puppeteer and Playwright haven't had a release since March 2023. For the signals sites score, read how websites detect scrapers.

We don't cover stealth plugins, patched forks, fingerprint tuning, or getting past CAPTCHA and bot challenges. Those steps exist to get around a control a site chose to turn on, and a challenge in particular is the site asking for a human.

What rendered pages cost

All three libraries are free and open source, but the browsers, servers, proxies and upkeep behind them aren't, so compare them with managed APIs on the cost of a page you can use. For 100,000 successful protected pages a month, credit-based APIs cost $249 to $399 at list price and GcrawlAI costs $101.

List-price arithmetic, not a benchmark. Credit costs and billing rules come from ScraperAPI's credit docs, ZenRows' pricing docs and ScrapingBee's FAQ, checked November 1, 2026. The honest read: for plain HTML, ZenRows, ScraperAPI and ScrapingBee cost less than GcrawlAI, and a self-run Playwright, Puppeteer or Selenium fleet costs servers and proxies rather than credits. At about 300 MB per headless browser in our lab, memory decides how many fit on a server. Count cost per page with your fields in it.

GcrawlAI plans (GcrawlAI pricing, checked October 28, 2026):

Every plan, Free included, has scrape, crawl, the Search API, JavaScript rendering, residential IP rotation and stealth escalation in each request, and each feature counts as one request. Failed requests are never charged. Annual billing charges 10 months for 12, unused requests on paid plans roll over once, and Indian customers are billed in INR with a GST invoice.

Which tool fits your project

Pick by your constraints, not by stars on GitHub. Language and existing code narrow the choice first, then browser coverage, then scale. Each library wins somewhere, and a managed API wins when you only want the page. The table shows where GcrawlAI fits in each case.

When your own Python is enough

Many pages that seem to need a browser don't. Check View Source and the browser's network tab first: if the data is in the HTML or a JSON endpoint, requests or httpx gets it faster and cheaper than any of these three tools. Keep a browser for pages that only build their content in JavaScript.

When you do need rendering and don't want to run browsers, move those pages to GcrawlAI and keep your field checks. Its free Cloud plan's 50 requests a month are enough to test your real targets, the Playground shows the result without code, and the MIT core self-hosts for free. For the build-or-buy trade-off, read web scraping with Python vs a scraping API.

Using browser automation responsibly

A real browser doesn't change what you're allowed to collect. Read the site's terms and robots.txt, prefer an official API or data licence, stay on public pages, keep request rates low, and don't collect personal data you have no basis to hold. When a site shows a CAPTCHA, stop and ask for access.

Leave logins, checkouts and account pages alone unless they're your own accounts and the terms allow automation. For the rules a site publishes, read how to check if a website allows scraping, and for the legal background, what web scraping is and where it's legal.

"Pick the tool your team can maintain at 2 a.m. A slightly slower scraper that people understand beats a fast one nobody wants to touch."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

Related guides

• 10 Best Headless Browsers for Scraping in 2026: Playwright, Camoufox, Cloud Browsers and More
• How to Scrape Dynamic JavaScript Websites with Python (2026 Guide)
• Python Web Scraping Frameworks Compared: Scrapy vs Crawlee vs Scrapling (2026)
• Nodriver and Undetected ChromeDriver: Python Tutorial
• Camoufox Tutorial: Scrape Without Getting Detected
• How Websites Detect Scrapers: 13 Signals Anti-Bot Systems Check
• Web Scraping Without Getting Blocked: The 2026 Playbook
• Web Scraping with Python vs a Scraping API