Playwright Stealth Setup for Large-Scale Scraping: Architecture & Best Practices (2026)

┌─────────────────────────────────────────────────────────────────────────────┐
│                 Production Headless Automation Failure Points               │
├─────────────────────────────────────────────────────────────────────────────┤
│ 1. Memory Bloat & Leaks      ──► Chromium processes consume 400MB-1GB each  │
│ 2. Broken WebSocket Pipes    ──► Stale CDP connections cause hanging jobs   │
│ 3. Synthetic Signature Flags ──► Default Playwright flags trigger WAF blocks│
│ 4. Single-Host Resource Caps ──► Multi-threaded CPU starvation on cloud VPS │
└─────────────────────────────────────────────────────────────────────────────┘

                               Chromium Parent Process
                       (150MB Baseline - Long-Lived Engine)
                                         │
        ┌────────────────────────────────┼────────────────────────────────┐
        ▼                                ▼                                ▼
  [Context 1]                      [Context 2]                      [Context 3]
  • Task: Amazon Price             • Task: Google Maps Leads        • Task: Instagram Profile
  • Memory: ~25 MB                 • Memory: ~30 MB                 • Memory: ~25 MB
  • Lifecycle: 1 Job               • Lifecycle: 1 Job               • Lifecycle: 1 Job
        │                                │                                │
        ▼                                ▼                                ▼
[Close & Clean Memory]           [Close & Clean Memory]           [Close & Clean Memory]

// pool-manager.ts - High-Throughput Playwright Context Pool
import { chromium, Browser, BrowserContext } from "playwright";

export class BrowserPool {
  private browser: Browser | null = null;
  private activeContexts: number = 0;
  private maxConcurrency: number;
  private totalJobsProcessed: number = 0;
  private readonly maxJobsBeforeRestart: number = 500;

  constructor(maxConcurrency: number = 8) {
    this.maxConcurrency = maxConcurrency;
  }

  async init(): Promise<void> {
    if (!this.browser) {
      this.browser = await chromium.launch({
        headless: true,
        args: [
          "--disable-dev-shm-usage", // Overcomes limited resource problems in Linux containers
          "--no-sandbox",
          "--disable-gpu",
          "--disable-blink-features=AutomationControlled",
        ],
      });
      console.log("🚀 Initialized parent Chromium browser instance");
    }
  }

  async acquireContext(): Promise<BrowserContext> {
    await this.init();

    // Recycle entire browser process after 500 jobs to eliminate deep V8 memory fragmentation
    if (this.totalJobsProcessed >= this.maxJobsBeforeRestart && this.activeContexts === 0) {
      console.log("♻️ Recycling parent browser process to flush memory leaks...");
      await this.browser?.close();
      this.browser = null;
      this.totalJobsProcessed = 0;
      await this.init();
    }

    const context = await this.browser!.newContext({
      viewport: { width: 1920, height: 1080 },
      userAgent:
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
    });

    this.activeContexts++;
    this.totalJobsProcessed++;
    return context;
  }

  async releaseContext(context: BrowserContext): Promise<void> {
    try {
      await context.close();
    } finally {
      this.activeContexts = Math.max(0, this.activeContexts - 1);
    }
  }

  async shutdown(): Promise<void> {
    if (this.browser) {
      await this.browser.close();
      this.browser = null;
    }
  }
}

// resilient-worker.ts - Heartbeat Supervisor & Crash Recovery
import { Page, BrowserContext } from "playwright";

export async function executeWithWatchdog<T>(
  context: BrowserContext,
  taskFn: (page: Page) => Promise<T>,
  timeoutMs: number = 30000
): Promise<T> {
  const page = await context.newPage();
  
  // Set execution deadline
  const timeoutPromise = new Promise<never>((_, reject) =>
    setTimeout(() => reject(new Error(`⏱️ Job timed out after ${timeoutMs}ms`)), timeoutMs)
  );

  // Heartbeat monitoring for crashed renderers
  page.on("crash", () => console.error("💥 Page crashed unexpectedly during execution"));

  try {
    return await Promise.race([taskFn(page), timeoutPromise]);
  } catch (error: any) {
    console.error(`❌ Execution error: ${error.message}`);
    throw error;
  } finally {
    if (!page.isClosed()) {
      await page.close().catch(() => {});
    }
  }
}

// stealth-injector.ts - Full Prototype & Sensor Shield
import { Page } from "playwright";

export async function injectProductionStealth(page: Page) {
  await page.addInitScript(() => {
    // 1. Cleanly strip navigator.webdriver
    Object.defineProperty(navigator, "webdriver", {
      get: () => undefined,
    });

    // 2. Mock plugins array to match desktop Chrome
    Object.defineProperty(navigator, "plugins", {
      get: () => [
        { name: "PDF Viewer", filename: "internal-pdf-viewer", description: "Portable Document Format" },
        { name: "Chrome PDF Viewer", filename: "internal-pdf-viewer", description: "Portable Document Format" },
      ],
    });

    // 3. Inject consistent WebGL parameters
    const getParameter = WebGLRenderingContext.prototype.getParameter;
    WebGLRenderingContext.prototype.getParameter = function (parameter: number) {
      if (parameter === 37445) return "Google Inc. (NVIDIA)";
      if (parameter === 37446) return "ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Direct3D11 vs_5_0 ps_5_0, D3D11)";
      return getParameter.apply(this, [parameter]);
    };

    // 4. Align Hardware Specs
    Object.defineProperty(navigator, "hardwareConcurrency", { get: () => 8 });
    Object.defineProperty(navigator, "deviceMemory", { get: () => 8 });

    // 5. Ensure chrome runtime object exists
    (window as any).chrome = {
      runtime: {},
      loadTimes: () => {},
      csi: () => {},
    };
  });
}

                  Claude Desktop / Cursor / AI Agents
                                   │
                                   ▼ (JSON-RPC)
                     ┌───────────────────────────┐
                     │ BrowserMesh MCP Gateway   │
                     │  (Token-Optimized DOM)    │
                     └─────────────┬─────────────┘
                                   │ Dispatched to local engine
                                   ▼
                     ┌───────────────────────────┐
                     │ BrowserMesh Node Fleet    │
                     │  (Local PCs & Mobile IPs) │
                     └─────────────┬─────────────┘
                                   │
                                   ▼
                     ┌───────────────────────────┐
                     │ Web Studio Live Monitor   │
                     │ (studio.browsermesh.in)   │
                     └───────────────────────────┘

# 1. Deploy the BrowserMesh headless daemon on Linux / macOS
curl -sSL https://www.browsermesh.in/scripts/install-headless.sh | bash

# 2. Check local engine status and system resource consumption
mesh status

# 3. Stream real-time Playwright execution logs and browser events
mesh logs