Playwright Web Scraping：Python 和 Node.js 完全指南

Playwright 是由 Google Puppeteer 团队（该团队后来转投微软）创建的浏览器自动化库。它通过单一统一的 API 控制 Chromium、Firefox 和 WebKit。使用 Playwright 进行网页抓取，其主要优势可归纳为以下几点：

• 多浏览器支持。您不会被锁定在 Chromium 生态中。需要测试渲染差异，或轮换浏览器引擎以减少指纹识别？Playwright 通过完全相同的方法调用即可处理这三种引擎。
• 多语言 SDK。官方提供了 Python、Node.js（JavaScript/TypeScript）、Java 和 .NET 的绑定库。本指南将重点介绍爬取领域中最受欢迎的两种选择：Python 和 Node.js。
• 自动等待。Playwright 会在与元素交互前自动等待其进入可操作状态。无需再手动 sleep() 调用以规避动态页面上的竞争条件。
• 无头和有头模式。通过一个布尔标志，即可在生产环境中使用无头模式提升速度，在调试时切换至有头模式。
• 网络拦截。您可以屏蔽图片、样式表和跟踪脚本以加快页面加载速度，或检查页面在后台发出的 API 响应。
• 浏览器上下文。在单个浏览器实例内创建隔离且 Cookie 分隔的会话。这比为每个任务启动新浏览器更高效，非常适合并发抓取。

这些特性使 Playwright 非常适合抓取动态的、由 JavaScript 渲染的页面——在这些页面中，普通的 HTTP 请求返回的有用标记内容很少。

在编写第一个脚本之前，了解哪些 Playwright 功能能直接应对常见的抓取挑战会很有帮助。

自动等待与智能断言。当您调用 page.locator('.price').text_content()时，Playwright 会等待该元素在 DOM 中存在且可见后才返回值。这消除了困扰旧版自动化工具的时序不稳定问题。

使用 page.route()。您可以拦截所有出站请求，屏蔽不需要的资源类型（如图片、字体、分析代码），修改请求头，甚至返回模拟响应。屏蔽不必要的资源可显著缩短页面加载时间，这对抓取数千个页面尤为重要。

并发浏览器上下文。无需为每个抓取任务启动独立的浏览器进程，您可以在单个浏览器中打开多个 BrowserContext 对象。每个上下文拥有独立的 Cookie、本地存储和缓存，因此会话保持隔离，同时避免了额外浏览器进程带来的内存开销。

内置隐身功能。Playwright 的新版本开箱即用，可修补多个常见的自动化检测指标，例如 navigator.webdriver flag。结合社区开发的隐身插件，可大幅缩小被检测的范围。

请求和响应事件钩子。通过 page.on('response', ...) 直接捕获 API 有效载荷。许多现代单页应用（SPA）从内部端点获取 JSON；拦截这些响应通常能提供比解析渲染后的 DOM 更干净的数据。

跟踪与调试。 trace 查看器支持逐帧回放抓取会话，包括截图、DOM 快照和网络日志。当选择器失效且您需要了解发生了哪些变化时，此功能尤为宝贵。

无论使用哪种语言，运行 Playwright 都只需不到两分钟。以下是两者的配置方法。

Python：

# Create a virtual environment and install playwright
pip install playwright
playwright install  # downloads Chromium, Firefox, and WebKit binaries

Node.js：

# Initialize a project and install playwright
npm init -y
npm install playwright
npx playwright install  # downloads browser binaries

两者的安装命令都会将浏览器二进制文件下载到本地。这些二进制文件总大小约为 200-400 MB，因此如果您在 CI/CD 环境或 Docker 容器中工作，请预留足够的空间。您也可以仅安装单个浏览器引擎（例如， playwright install chromium）以节省磁盘空间。

最低要求：Python 3.8+ 或 Node.js 16+。Playwright 会自行管理浏览器二进制文件，因此您无需在系统层面安装 Chrome 或 Firefox。

Playwright 的 Python SDK 同时提供了同步和异步接口。同步 API 更简单，适用于按顺序抓取页面的单线程脚本。

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()

异步 API 使用 Python 的 asyncio ，当您需要并行抓取多个页面时，它是更优的选择。它允许您在单个事件循环内并行运行多个浏览器上下文或页面。

import asyncio
from playwright.async_api import async_playwright

async def scrape():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto("https://example.com")
        print(await page.title())
        await browser.close()

asyncio.run(scrape())

何时选择哪种：快速脚本、原型开发和顺序抓取任务请使用同步模式。当您需要抓取数百或数千个页面，且希望在不启动多个进程的情况下实现并发时，请切换到异步模式。在 Node.js 中，该 API 本质上是基于 Promise 的（异步），因此没有单独的同步模式可供选择。

让我们构建一个最简版的爬虫，它将导航至某个页面，提取 <h1> 文本并将其打印出来。这将演示你在每个 Playwright 网页抓取项目中都会用到的核心工作流。

Python（同步）：

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://books.toscrape.com/")
    heading = page.locator("h1").text_content()
    print(f"Page heading: {heading}")
    browser.close()

Node.js：

const { chromium } = require('playwright');

(async () => {
    const browser = await chromium.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://books.toscrape.com/');
    const heading = await page.locator('h1').textContent();
    console.log(`Page heading: ${heading}`);
    await browser.close();
})();

这两种语言的模式相同：启动浏览器、创建页面、导航、定位元素、提取内容，然后清理。在此基础上，只需添加更多定位器、导航步骤和数据处理逻辑，即可实现功能扩展。

几点注意事项： headless: true （或 headless=True 在 Python 中）会以无可见窗口的方式运行浏览器。当您需要观察浏览器与页面的交互以进行调试时，请将其设置为 false/False 。 locator() 方法是 Playwright 推荐的元素查找方式；它返回一个懒加载引用，支持自动等待和自动重试。

在页面上找到正确的元素是任何使用 Playwright 进行网页抓取工作流的核心技能。Playwright 支持 CSS 选择器、XPath 表达式及其专有的基于文本的选择器。

CSS 选择器是最常见的选择。它们简洁且性能优异：

# Python
titles = page.locator("article.product_pod h3 a")
for i in range(await titles.count()):
    print(await titles.nth(i).text_content())

// Node.js
const titles = page.locator('article.product_pod h3 a');
const count = await titles.count();
for (let i = 0; i < count; i++) {
    console.log(await titles.nth(i).textContent());
}

当 DOM 结构复杂或类名动态生成时，XPath 选择器非常有用：

# Python
price = page.locator("xpath=//p[@class='price_color']").first.text_content()

基于文本的选择器允许您根据元素的可见文本进行定位，这比在部署过程中可能发生变化的类名更具鲁棒性：

# Python
page.locator("text=Add to basket").click()

实用技巧：可将浏览器开发者工具的“复制选择器”功能作为起点，但务必简化生成的选择器。自动生成的选择器往往不稳定，因为其中包含深度嵌套的路径，一旦布局发生变化就会失效。建议使用简短、具体的选择器，并锚定在稳定的属性上，例如 data-testid 或语义类名等稳定属性作为锚点。

在确定好选择器后，下一步是从页面中提取结构化数据。以下是一个实用的 Playwright 爬取教程，演示如何从一个示例书店网站中提取图书标题和价格。

Python：

from playwright.sync_api import sync_playwright

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

    books = page.locator("article.product_pod")
    results = []
    for i in range(books.count()):
        book = books.nth(i)
        title = book.locator("h3 a").get_attribute("title")
        price = book.locator(".price_color").text_content()
        results.append({"title": title, "price": price})

    for r in results:
        print(f"{r['title']}: {r['price']}")
    browser.close()

Node.js：

const { chromium } = require('playwright');

(async () => {
    const browser = await chromium.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://books.toscrape.com/');

    const books = page.locator('article.product_pod');
    const count = await books.count();
    const results = [];
    for (let i = 0; i < count; i++) {
        const book = books.nth(i);
        const title = await book.locator('h3 a').getAttribute('title');
        const price = await book.locator('.price_color').textContent();
        results.push({ title, price });
    }
    console.log(results);
    await browser.close();
})();

值得重点关注的几个模式： get_attribute("title") (Python) 和 getAttribute('title') (Node.js) 提取的是属性值，而非内部文本。这对于工具提示文本、href 值和 data 属性非常有用。 text_content() 方法返回元素内部的原始文本，而 inner_text() 则返回渲染后的（可见）文本。在抓取结构化数据时， text_content() 通常是更优的选择，因为它速度更快且不会触发布局重算。

文本只是画面的一部分。许多抓取项目需要下载图片、PDF 或其他二进制文件。以下是使用 Playwright 网络抓取提取图片 URL 并本地保存文件的方法。

Python：

import httpx
from playwright.sync_api import sync_playwright

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

    images = page.locator("article.product_pod img")
    base_url = "https://books.toscrape.com/"
    for i in range(images.count()):
        src = images.nth(i).get_attribute("src")
        full_url = base_url + src
        response = httpx.get(full_url)
        with open(f"image_{i}.jpg", "wb") as f:
            f.write(response.content)
        print(f"Saved image_{i}.jpg")
    browser.close()

Node.js：

const { chromium } = require('playwright');
const fs = require('fs');

(async () => {
    const browser = await chromium.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://books.toscrape.com/');

    const images = page.locator('article.product_pod img');
    const count = await images.count();
    const baseUrl = 'https://books.toscrape.com/';
    for (let i = 0; i < count; i++) {
        const src = await images.nth(i).getAttribute('src');
        const response = await page.request.get(baseUrl + src);
        fs.writeFileSync(`image_${i}.jpg`, await response.body());
        console.log(`Saved image_${i}.jpg`);
    }
    await browser.close();
})();

Node.js 版本使用 Playwright 内置的 page.request API 上下文，该上下文与页面会话共享 Cookie 和请求头。在 Python 中，则需使用外部 HTTP 库（如 httpx 或 requests) 运行良好。如果图片需要身份验证，请使用 Playwright 自带的请求上下文来自动携带会话 Cookie。

实际的网页抓取很少能仅靠单个页面完成。您会遇到带编号的分页、“加载更多”按钮以及无限滚动模式。以下是针对每种情况的可复用方法。

带页码的分页（点击“下一页”直至该按钮消失）：

# Python
results = []
while True:
    # Extract data from current page
    items = page.locator(".product_pod h3 a")
    for i in range(items.count()):
        results.append(items.nth(i).get_attribute("title"))

    next_btn = page.locator("li.next a")
    if next_btn.count() == 0:
        break
    next_btn.click()
    page.wait_for_load_state("networkidle")

print(f"Collected {len(results)} items across all pages")

无限滚动（向下滚动直至不再加载新内容）：

// Node.js
let previousHeight = 0;
while (true) {
    await page.evaluate('window.scrollTo(0, document.body.scrollHeight)');
    await page.waitForTimeout(2000); // allow content to load
    const currentHeight = await page.evaluate('document.body.scrollHeight');
    if (currentHeight === previousHeight) break;
    previousHeight = currentHeight;
}
// Now extract all loaded items
const items = await page.locator('.item').allTextContents();

无限滚动模式通过比较滚动前后的页面高度来判断。当高度停止变化时，即表示已到达页面底部。请根据目标网站加载新内容的速度调整超时时间。对于“加载更多”按钮，处理方法与带编号分页类似：定位按钮、点击按钮、等待新内容加载，然后重复此过程。

Playwright 用于网页抓取的最强大功能之一，就是能够通过 page.route()。这使您能够屏蔽不必要的资源、修改请求头，或直接捕获 API 响应。

屏蔽图片和样式表以加快抓取速度：

# Python
def block_resources(route):
    if route.request.resource_type in ["image", "stylesheet", "font"]:
        route.abort()
    else:
        route.continue_()

page.route("**/*", block_resources)
page.goto("https://example.com")

// Node.js
await page.route('**/*', (route) => {
    const type = route.request().resourceType();
    if (['image', 'stylesheet', 'font'].includes(type)) {
        return route.abort();
    }
    return route.continue();
});
await page.goto('https://example.com');

在媒体资源密集的网站上，屏蔽图片、字体和 CSS 可将页面加载时间缩短 40-60%，当进行大规模抓取时，这种节省效果会迅速累积。

拦截 API 响应：许多单页应用（SPA）会从内部 REST 或 GraphQL 端点获取数据。与其解析渲染后的 DOM，不如监听这些响应并直接获取原始 JSON：

# Python
def capture_api(response):
    if "/api/products" in response.url:
        data = response.json()
        print(f"Captured {len(data['items'])} products from API")

page.on("response", capture_api)
page.goto("https://example-spa.com/products")

与 DOM 抓取相比，此方法通常能获取更干净、结构更清晰的数据，且对布局变化具有更强的适应性。正如 Playwright 关于网络事件的文档所解释的，您可以通过 URL 模式、响应状态码和内容类型进行过滤。

当进行一定规模的抓取时，您需要使用代理将请求分散到不同的 IP 地址上。Playwright 支持在浏览器级别或按上下文配置代理。

浏览器级代理：

# Python
browser = p.chromium.launch(
    headless=True,
    proxy={"server": "http://proxy-host:8080"}
)

需身份验证的代理：

// Node.js
const browser = await chromium.launch({
    proxy: {
        server: 'http://proxy-host:8080',
        username: 'user',
        password: 'pass'
    }
});

上下文级代理（用于轮换）：轮换代理的实用模式是为每个代理创建一个新的浏览器上下文，从而能够循环使用一组代理地址：

# Python
proxies = ["http://proxy1:8080", "http://proxy2:8080", "http://proxy3:8080"]
for i, url in enumerate(urls_to_scrape):
    proxy = proxies[i % len(proxies)]
    context = browser.new_context(proxy={"server": proxy})
    page = context.new_page()
    page.goto(url)
    # ... scrape data ...
    context.close()

对于生产环境的工作负载，建议选择能为您处理轮换和会话管理的代理提供商，这样您的抓取代码就能专注于数据提取，而非基础设施管理。

网站会采用各种技术来检测并阻止自动化浏览器。要实现有效的 Playwright 无头抓取，必须尽量减少自动化指纹。

User-agent 轮换是最简单的切入点。通过浏览器上下文设置一个真实的 User-agent 字符串：

# Python
context = browser.new_context(
    user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
)

隐身插件可修补常见的自动化泄露漏洞。在 Python 中， playwright-stealth 包应用了一套规避技术（隐藏 navigator.webdriver、伪造 WebGL 供应商字符串、随机化插件数组）：

# Python
from playwright_stealth import stealth_sync

page = browser.new_page()
stealth_sync(page)
page.goto("https://example.com")

在 Node.js 中， playwright-extra 和 puppeteer-extra-plugin-stealth 包提供了类似的功能。

行为模仿可增加另一层保护。不要立即跳转到目标元素，而是添加微小的随机延迟、滚动页面并移动鼠标。这些微行为使您的流量模式看起来更像人类：

import random, time
page.mouse.move(random.randint(100, 500), random.randint(100, 500))
time.sleep(random.uniform(0.5, 2.0))

视口与区域设置的随机化。在每个上下文中设置逼真的视口尺寸、时区和区域设置，可进一步降低您的指纹识别风险。避免使用许多自动化脚本默认配备的 800x600 视口。

没有任何单一技术是万能的。有效的反检测策略需要结合隐身插件、代理轮换、逼真的浏览器指纹以及类人浏览模式。

生产环境中的爬虫必须能够应对意外情况：超时、导航失败、元素缺失以及速率限制。以下介绍如何为 Playwright 网页爬取脚本构建容错机制，以及如何保存爬取结果。

超时处理：

# Python
from playwright.sync_api import TimeoutError as PlaywrightTimeout

try:
    page.goto("https://example.com", timeout=15000)
    title = page.locator("h1").text_content(timeout=5000)
except PlaywrightTimeout:
    print("Page or element load timed out")

重试的指数退避策略：

import time

def scrape_with_retry(page, url, max_retries=3):
    for attempt in range(max_retries):
        try:
            page.goto(url, timeout=15000)
            return page.locator("h1").text_content()
        except Exception as e:
            wait = 2 ** attempt
            print(f"Attempt {attempt+1} failed: {e}. Retrying in {wait}s")
            time.sleep(wait)
    return None

导出为 CSV：

import csv

with open("results.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "price"])
    writer.writeheader()
    writer.writerows(results)

导出为 JSON：

// Node.js
const fs = require('fs');
fs.writeFileSync('results.json', JSON.stringify(results, null, 2));

对于大型抓取项目，建议将结果写入数据库（本地开发使用 SQLite，生产环境使用 PostgreSQL），而非存储为平面文件。这样既能恢复中断的任务，又能去除重复记录，还能在不将所有数据加载到内存的情况下进行查询。

若您正在为数据抓取选择浏览器自动化工具，这三者是主要候选方案。以下是在数据提取最关键的维度上，它们的对比情况。

<!-- 需进一步研究：独立性能基准测试（Playwright 与 Puppeteer 及 Selenium 的延迟和吞吐量对比），以定量数据补充此功能对比 -->

何时选择 Playwright：您需要多浏览器支持，团队使用 Python 或 Node.js，且希望在不依赖额外库的情况下直接使用内置的自动等待和网络拦截功能。这是最现代化的选择，非常适合抓取以 JavaScript 为主的应用程序。

何时选择 Puppeteer：您的技术栈仅限 Node.js，且目标仅为 Chromium 浏览器。Puppeteer 的生态系统已相当成熟，许多现成的抓取方案都是为其编写的。

何时选择 Selenium：您需要在数据抓取的同时支持旧版浏览器测试，或者您的组织已拥有现成的 Selenium 基础设施。其语言支持范围最广，但在处理现代抓取任务时需要更多冗余代码。

• Playwright 原生支持动态内容处理。其自动等待、网络拦截及多浏览器支持功能，使其成为抓取那些简单 HTTP 客户端无法处理的 JavaScript 渲染网站的理想选择。
• 同时使用 Python 和 Node.js。Playwright 的 API 在不同语言中几乎完全一致。选择适合您现有技术栈的语言，并在项目需要时自由切换。
• 屏蔽非必要资源。拦截并中止图片、字体和样式表的请求可显著缩短抓取时间，尤其在规模化抓取时效果显著。
• 分层构建反检测机制。仅靠隐身插件是不够的。将其与代理轮换、用户代理随机化、视口设置以及类人延迟相结合，才能确保访问的可靠性。
• 为故障做好准备。将每个导航和数据提取调用都封装在带有指数退避机制的错误处理中。采用增量导出数据，以避免在长时间运行中丢失进度。

对于抓取现代、大量使用 JavaScript 的网站，Playwright 通常能提供更流畅的体验。它内置了自动等待、原生网络拦截功能，并支持多浏览器，无需额外驱动程序。Selenium 拥有更广泛的语言生态系统和更大的社区，但需要更多冗余代码和第三方工具才能实现与 Playwright 抓取相关功能相当的效果。

是的。开箱即用的无头 Playwright 会暴露若干自动化指标，这些指标会被先进的反机器人服务检测到，包括 navigator.webdriver 属性以及特定的浏览器指纹异常。隐身插件可降低此类暴露风险，但没有任何浏览器自动化工具能完全避免被检测。部署了高级反机器人防护的网站仍可能基于行为分析将自动化会话标记为异常。

是的。通过 headless=True (Python) 或 headless: true (Node.js) 参数来启动浏览器以进行无头操作。将值设置为 false 以打开可见的浏览器窗口。无头模式速度更快且占用内存更少，因此是生产环境抓取的默认选项。有头模式主要在开发和调试阶段有用。

验证码旨在阻止自动化操作，目前没有任何浏览器自动化工具内置可靠的程序化解决方案。常见方法包括：通过 API 回调集成第三方验证码破解服务、轮换住宅代理以降低触发验证码的频率，以及降低请求频率以保持在检测阈值以下。对于大规模抓取，使用能够透明处理验证码的托管抓取服务通常是最实用的方案。

Python 和 Node.js 是两种最受欢迎的选择，且两者均对 Playwright 支持出色。当您的处理流程涉及 pandas 等数据分析库，或团队已使用 Python 开发时，Python 是更优选。若您的技术栈以 JavaScript 为核心，或希望复用前端选择器，Node.js 则是自然之选。由于实际的浏览器自动化运行在相同的底层引擎中，无论调用语言为何，这两种绑定之间的性能差异可以忽略不计。

Playwright 网络爬虫为您提供了一套现代且支持完善的工具集，用于从那些能轻易规避简单方法的网站中提取数据。从自动等待和网络拦截，到并发浏览器上下文和内置隐身功能，它处理了浏览器自动化的难点，让您能够专注于数据本身。

本文涵盖的技术，包括选择器策略、请求拦截、代理配置、反检测、分页和结构化导出，构成了任何严肃爬取项目的基础。从简单的脚本开始，逐步加入错误处理和重试机制，并随着工作负载的增长利用异步上下文进行扩展。

若您发现管理代理、验证码及浏览器基础设施所耗费的工程时间已超过实际数据提取的时间，不妨考虑将这一层工作卸载至专用服务。我们的 Scraper API 通过单一接口处理代理轮换、验证码破解及反机器人绕过机制，让您能够专注于 Playwright 的解析逻辑，无需再为请求管道操心。