What Is Puppeteer?

Puppeteer's own documentation defines it as "a JavaScript library which provides a high-level API to control Chrome or Firefox over the DevTools Protocol or WebDriver BiDi" (pptr.dev). In plain words: instead of you clicking in a browser, a Node.js script does it, as fast as the page allows and as many times as you need. It is published under the Apache-2.0 license, so you can use it in commercial projects at no cost.

Developers use Puppeteer wherever a person would otherwise repeat the same steps in a browser. The official guide lists form submission, UI testing, performance traces, Chrome extension testing, screenshots and PDFs, and pre-rendering single-page apps (pptr.dev). In practice:

Screenshot and PDF in a few lines:

// npm i puppeteer   ->   node capture.mjs
import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto('https://example.com');
await page.screenshot({ path: 'example.png', fullPage: true });
await page.pdf({ path: 'example.pdf', format: 'A4' });   // PDF needs headless mode, the default
await browser.close();

Puppeteer starts a browser process and talks to it over a protocol. For Chrome that is the Chrome DevTools Protocol (CDP), the same channel Chrome's developer tools use; for Firefox it is WebDriver BiDi, the W3C standard that is the default for automating Firefox (WebDriver BiDi guide). Your script calls methods such as page.goto() or page.click(), Puppeteer turns them into protocol messages, and the browser does the work.

Each Puppeteer release is bundled with a specific browser version, so the library and the browser always speak the same protocol version. Since v20.0.0 it downloads Chrome for Testing, a Chrome build made for automation, and since v23.0.0 it supports Firefox as well (supported browsers).

A minimal script:

// npm i puppeteer   ->   node title.mjs
import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();            // headless Chrome
const page = await browser.newPage();
await page.goto('https://example.com', { waitUntil: 'networkidle2' });
const title = await page.$eval('h1', el => el.textContent);
console.log(title);                                  // "Example Domain"
await browser.close();

Yes on both counts. Puppeteer was created at Google, and its FAQ states: "The Chrome Browser Automation team maintains the library." The docs site carries "Copyright © 2026 Google, Inc." (pptr.dev/faq). It is an open-source project on GitHub under Apache-2.0 that accepts outside contributions; Google sells no paid edition or support contract, and the FAQ does not describe it as a supported Google product. "Google Puppeteer" in search usually means this library.

It is actively maintained. The last three releases, from the GitHub releases page:

The maintenance signals in the official docs:

• Firefox support since v23.0.0, over WebDriver BiDi (FAQ).
• Chrome for Testing downloaded by default since v20.0.0 (supported browsers).
• CDP stays for Chrome: "We are not going to stop supporting automation of Chrome with CDP." (FAQ)
• One browser per release: "Every Puppeteer release is tightly bundled with a specific browser release," so a new Chrome means a new Puppeteer version.

Puppeteer runs the browser headless by default: the browser renders pages fully, runs JavaScript and loads resources, but shows no window. Pass headless: false to watch it work, which helps while you write and debug a script. Since Chrome 132, Chrome's old headless implementation exists only as a separate program, chrome-headless-shell; Puppeteer uses it when you set headless: 'shell' (Chrome for Developers). The difference between the two headless modes is covered in what a headless browser is.

You can also point Puppeteer at a Chrome you installed yourself with executablePath, or connect to a running Chrome with puppeteer.connect(). The lighter puppeteer-core package does not download a browser at all, for setups that bring their own.

Not directly: Puppeteer is a Node.js library, with no official Python package. Pyppeteer, an unofficial Python port, copied its API, but its README now says: "Attention: This repo is unmaintained and has been outside of minor changes for a long time. Please consider playwright-python as an alternative." (Pyppeteer on GitHub).

For browser automation from Python in 2026, use Playwright for Python or Selenium. The Playwright equivalent of the Puppeteer proxy setup below, with the same gateway:

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

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={
        "server": "http://gate.proxyfield.io:7000",
        "username": "<login>-country-us-city-new_york",
        "password": "<password>",
    })
    page = browser.new_page()
    page.goto("https://api.ipify.org?format=json")
    print(page.inner_text("body"))   # the proxy's IP
    browser.close()

More in Playwright proxy setup, Puppeteer vs Playwright and Python web scraping.

Advantages:

• Close to Chrome: new DevTools features usually reach Puppeteer first.
• One install gives you a matching browser, so versions do not drift.
• A small, readable API that covers pages, frames, network interception, cookies, downloads, screenshots and PDFs.
• Free under Apache-2.0, with a large body of examples and answers online.

Limits:

• Node.js only; no official Python, Java or .NET packages.
• Chrome and Firefox only; no WebKit (Safari's engine).
• No test runner of its own: you add Jest, Mocha or another runner.
• A real browser per job: much more CPU, memory and traffic than an HTTP request.
• Sites that limit requests per IP will block a busy Puppeteer script from one IP, as they would any client.

Yes. Puppeteer shipped three releases between 14 and 22 October 2026, supports Firefox since v23.0.0, and remains the reference automation library for Chrome. Playwright is common in new cross-browser test suites, because it covers three browser engines and four languages, but Puppeteer stays a sound choice for Chrome automation in Node.js. Alternatives and when they make sense: Puppeteer alternatives.

Puppeteer is worth its cost when a page builds its content with JavaScript, or when you must click, scroll or fill in a form before the data appears. Before you reach for it, open the browser's network tab: many pages load their data from a JSON request that a plain HTTP client can call directly, at a fraction of the traffic.

When you do scrape with it:

• Wait for the element you need (page.waitForSelector() or a locator) instead of fixed sleeps.
• Block images, fonts and media with request interception to cut load time and traffic.
• Reuse one browser and open new pages or contexts, instead of launching a browser per URL.
• Pace requests and respect the site's robots.txt and terms; scrape public data only (is web scraping legal).

A full tutorial is in web scraping with Puppeteer.