Selenium vs Puppeteer vs Playwright: a side-by-side comparison

LumaBrowser exposes two servers and three supported clients. Puppeteer and Playwright both speak CDP, so they share a server:

                    ┌───────────────────────────── LumaBrowser ─────────────────────────────┐
                    │                                                                       │
  selenium-driver   │    Selenium WebDriver server  ──▶ port 9515  (W3C WebDriver / HTTP)   │
                    │                                                                       │
                    │                                              ┌─▶ Puppeteer clients    │
  cdp-driver        │    CDP WebSocket server       ──▶ port 9222 ─┤                        │
                    │    (shared endpoint)                         └─▶ Playwright           │
                    │                                                  (connectOverCDP)     │
                    │                                                  & Playwright MCP      │
                    │                                                                       │
                    │                ┌──────────────── Lumabyte fallback orchestrator ──┐   │
                    │                │  deterministic match → LLM attempt → validation  │   │
                    │                │         (shared by all three protocol paths)     │   │
                    │                └──────────────────────────────────────────────────┘   │
                    └───────────────────────────────────────────────────────────────────────┘

The CDP server handles Puppeteer and Playwright as two clients of the same endpoint — that’s why puppeteer.connect({ browserURL: 'http://127.0.0.1:9222' }) and chromium.connectOverCDP('http://127.0.0.1:9222') both work, and both pick up the Lumabyte.* custom domain for free.

Before we dive into differences, the things that are not a tradeoff:

• The same LLM selector fallback. Natural-language element resolution (ai-description in Selenium, Lumabyte.find/Lumabyte.click for Puppeteer and Playwright) routes through one shared orchestrator: deterministic accessibility match → LLM attempt → validation → background shadow-template regeneration. Improvements to the pipeline ship to all three drivers at once.
• The same LLM slot. All three drivers call the core selector-resolver slot. Configure a fast, low-latency model once and every description-based call from any client benefits.
• The same DOM-snapshot shortcut. Single-round-trip page capture: POST /lumabyte/dom/snapshot in Selenium, Lumabyte.domSnapshot via CDP for Puppeteer and Playwright.
• The same MCP control surface. Start, stop, and inspect either driver from Claude or any MCP client using the selenium_driver_* or cdp_driver_* tools.
• The same host process. Every driver lives in-process with the browser — no ChromeDriver binary, no bundled Chromium child, no version drift.

Same browser, same LumaBrowser instance, three different handshakes:

# pip install selenium
from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Remote(
    "http://127.0.0.1:9515",
    options=webdriver.ChromeOptions(),
)

# Operates on whichever tab is active
# in LumaBrowser.
driver.get("https://example.com")
title = driver.find_element(
    By.CSS_SELECTOR, "h1",
).text
print(title)

driver.quit()

// npm install puppeteer-core
const puppeteer =
  require('puppeteer-core');

const browser = await puppeteer.connect({
  browserURL: 'http://127.0.0.1:9222',
});

// Spawns a "CDP" tab inside LumaBrowser.
const page = await browser.newPage();
await page.goto('https://example.com');

console.log(await page.title());

await browser.disconnect();

// npm install playwright
const { chromium } = require('playwright');

const browser = await chromium.connectOverCDP(
  'http://127.0.0.1:9222',
);

// Default BrowserContext is pre-advertised,
// so .contexts()[0] resolves on connect.
const context = browser.contexts()[0]
  ?? await browser.newContext();
const page = await context.newPage();
await page.goto('https://example.com');

console.log(await page.title());

await browser.close();

The Puppeteer and Playwright examples both land on the same WebSocket at ws://127.0.0.1:9222/devtools/browser/{uuid}. Same server, same targets, same Lumabyte.* domain — just two idiomatic client shapes.

The LumaByte differentiator. Vanilla Selenium, Puppeteer, and Playwright all ship without a deterministic-first LLM fallback for element resolution. All three drivers expose it here — only the dispatch syntax differs.

opts = webdriver.ChromeOptions()
opts.set_capability(
  "lumabyte:llmFallback", { "enabled": True },
)
driver = webdriver.Remote(
  "http://127.0.0.1:9515", options=opts,
)

# Skip CSS entirely.
link = driver.find_element(
  "ai-description",
  "the more information link",
)

btn = driver.find_element(
  "ai-description",
  "the add to cart button",
)
btn.click()

const cdp =
  await page.target().createCDPSession();

await cdp.send(
  'Lumabyte.configureFallback',
  { enabled: true },
);

// Tries selector first, LLM only on miss.
const r = await cdp.send('Lumabyte.find', {
  description: 'the more information link',
  selector:    'a.cta-deprecated',
});

await cdp.send('Lumabyte.click', {
  description: 'the add to cart button',
});

const cdp =
  await context.newCDPSession(page);

await cdp.send(
  'Lumabyte.configureFallback',
  { enabled: true },
);

// Same domain, same pipeline, same server.
const r = await cdp.send('Lumabyte.find', {
  description: 'the more information link',
  selector:    'a.cta-deprecated',
});

await cdp.send('Lumabyte.click', {
  description: 'the add to cart button',
});

Capabilities overlap heavily. The decision is about ergonomics and which ecosystem your stack already lives in.

Still unsure? All three are off by default. Enable them in LumaBrowser’s settings and try the same flow against each — they run concurrently without interfering with each other.

1. Settings. Open Settings → Selenium or Settings → CDP Driver, check “Start automatically when LumaBrowser launches”, then click Save & Start.

2. REST.

# Start the Selenium WebDriver server (port 9515)
curl -X POST http://localhost:3000/api/selenium/start

# Start the CDP server (port 9222) — Puppeteer and Playwright both attach here
curl -X POST http://localhost:3000/api/cdp/start

# Check both
curl http://localhost:3000/api/selenium/status
curl http://localhost:3000/api/cdp/status

Full references:

• Selenium Driver documentation
• CDP Driver documentation — covers both Puppeteer and Playwright attachment
• LumaBrowser vs Selenium — drop-in WebDriver story
• LumaBrowser vs Puppeteer — Puppeteer-focused deep dive
• LumaBrowser vs Playwright — connectOverCDP + Playwright MCP

Install LumaBrowser, enable any driver (or all), and point your existing client at the local port. The natural-language resolver is waiting.