selenium-wire 5.1.0

简单示例

from seleniumwire import webdriver  # Import from seleniumwire

# Create a new instance of the Chrome driver
driver = webdriver.Chrome()

# Go to the Google home page
driver.get('https://www.google.com')

# Access requests via the `requests` attribute
for request in driver.requests:
    if request.response:
        print(
            request.url,
            request.response.status_code,
            request.response.headers['Content-Type']
        )

打印

https://www.google.com/ 200 text/html; charset=UTF-8
https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_120x44dp.png 200 image/png
https://consent.google.com/status?continue=https://www.google.com&pc=s&timestamp=1531511954&gl=GB 204 text/html; charset=utf-8
https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_272x92dp.png 200 image/png
https://ssl.gstatic.com/gb/images/i2_2ec824b0.png 200 image/png
https://www.google.com/gen_204?s=webaft&t=aft&atyp=csi&ei=kgRJW7DBONKTlwTK77wQ&rt=wsrt.366,aft.58,prt.58 204 text/html; charset=UTF-8
...

功能

• 纯Python，用户友好的API

• 捕获HTTP和HTTPS请求

• 截获请求和响应

• 在实时中修改头部、参数、正文内容

• 捕获WebSocket消息

• 支持HAR格式

• 支持代理服务器

兼容性

• Python 3.7+

• Selenium 4.0.0+

• Chrome、Firefox、Edge和远程Webdriver支持

目录

• 安装

  • 浏览器设置

  • OpenSSL

• 创建Webdriver

• 访问请求

• 请求对象

• 响应对象

• 截获请求和响应

  • 示例：添加请求头

  • 示例：替换现有请求头

  • 示例：添加响应头

  • 示例：添加请求参数

  • 示例：更新POST请求体中的JSON

  • 示例：基本认证

  • 示例：阻止请求

  • 示例：模拟响应

  • 取消设置拦截器

• 限制请求捕获

• 请求存储

  • 内存存储

• 代理

  • SOCKS

  • 动态切换

• 机器人检测

• 证书

  • 使用您自己的证书

• 所有选项

• 许可证

安装

使用pip安装

pip install selenium-wire

如果您收到无法构建cryptography的错误，您可能正在运行pip的老版本。请尝试使用 python -m pip install --upgrade pip 升级pip，然后重新运行上述命令。

# For apt based Linux systems
sudo apt install openssl

# For RPM based Linux systems
sudo yum install openssl

# For Linux alpine
sudo apk add openssl

brew install openssl

创建Webdriver

确保您从 seleniumwire 包导入 webdriver

from seleniumwire import webdriver

然后就像您直接使用Selenium一样实例化webdriver。您可以为任何期望的功能或浏览器特定选项传递参数，例如可执行文件路径、无头模式等。Selenium Wire还有其自己的选项，这些选项可以通过 seleniumwire_options 属性传递。

# Create the driver with no options (use defaults)
driver = webdriver.Chrome()

# Or create using browser specific options and/or seleniumwire_options options
driver = webdriver.Chrome(
    options = webdriver.ChromeOptions(...),
    seleniumwire_options={...}
)

请注意，对于 webdriver 的子包，您应继续直接从 selenium 导入这些内容。例如，要导入 WebDriverWait

# Sub-packages of webdriver must still be imported from `selenium` itself
from selenium.webdriver.support.ui import WebDriverWait

远程Webdriver

Selenium Wire对使用远程webdriver客户端的支持有限。当您创建远程webdriver实例时，您需要指定运行Selenium Wire的机器（或容器）的主机名或IP地址。这允许远程实例通过其请求和响应与其请求回Selenium Wire。

options = {
    'addr': 'hostname_or_ip'  # Address of the machine running Selenium Wire. Explicitly use 127.0.0.1 rather than localhost if remote session is running locally.
}
driver = webdriver.Remote(
    command_executor='http://www.example.com',
    seleniumwire_options=options
)

如果运行浏览器的机器需要使用不同的地址与运行Selenium Wire的机器通信，您需要手动配置浏览器。有关此问题的更多详细信息，请参阅 此问题。

访问请求

Selenium Wire捕获浏览器发出的所有HTTP/HTTPS流量 [1]。以下属性提供了对请求和响应的访问权限。

driver.requests

按时间顺序排列的捕获请求列表。

driver.last_request

方便属性，用于获取最近捕获的请求。这比使用 driver.requests[-1] 更有效。

driver.wait_for_request(pat, timeout=10)

此方法将等待直到看到匹配模式的请求。 pat 属性将在请求URL内进行匹配。pat 可以是一个简单的子串或正则表达式。请注意，driver.wait_for_request() 并不会 发送 请求，它只是 等待 上一个动作发送的请求，并将返回它找到的第一个请求。另外请注意，由于 pat 可以是正则表达式，您必须用斜杠转义特殊字符，例如将问号转义。如果在超时期间没有找到匹配项，将引发 TimeoutException。

例如，要等待在按钮点击后返回的AJAX请求

# Click a button that triggers a background request to https://server/api/products/12345/
button_element.click()

# Wait for the request/response to complete
request = driver.wait_for_request('/api/products/12345/')

driver.har

一个JSON格式的HAR存档，包含了已经发生的HTTP交易。HAR捕获默认是关闭的，您必须在使用 driver.har 之前将 enable_har 选项 设置为 True。

driver.iter_requests()

返回一个捕获请求的迭代器。当处理大量请求时非常有用。

driver.request_interceptor

用于设置请求拦截器。参见 拦截请求和响应。

driver.response_interceptor

用于设置响应拦截器。

清除请求

要清除之前捕获的请求和HAR条目，请使用 del

del driver.requests

请求对象

请求对象有以下属性。

body

请求体，以 bytes 的形式。如果请求没有体，则 body 的值将为空，即 b''。

cert

以字典格式表示的关于服务器SSL证书的信息。对于非HTTPS请求为空。

date

请求的日期和时间。

headers

类似字典的对象，包含请求头。头的大小写不敏感，允许重复。请求 request.headers['user-agent'] 将返回 User-Agent 头的值。如果您想替换一个头，请确保首先使用 del request.headers['header-name'] 删除现有的头，否则您将创建一个重复项。

host

请求的主机，例如 www.example.com

method

HTTP方法，例如 GET 或 POST 等。

params

请求参数的字典。如果请求中存在同名参数，则其在字典中的值将是一个列表。

path

请求路径，例如 /some/path/index.html

querystring

查询字符串，例如 foo=bar&spam=eggs

response

与请求相关联的 响应对象。如果没有响应，则此将为 None。

url

请求URL，例如 https://www.example.com/some/path/index.html?foo=bar&spam=eggs

ws_messages

如果请求是websocket握手请求（通常URL以 wss:// 开头），则 ws_messages 将包含发送和接收的任何websocket消息列表。参见 WebSocketMessage 对象。

请求对象有以下方法。

abort(error_code=403)

使用提供的错误代码触发请求的立即终止。用于请求拦截器内。参见 示例：阻止请求。

create_response(status_code, headers=(), body=b'')

创建一个响应并返回它，而不向远程服务器发送任何数据。用于请求拦截器内。参见 示例：模拟响应。

响应对象

响应对象具有以下属性。

body

响应体作为bytes。如果响应没有主体，则body的值将为空，即b''。有时服务器可能会压缩主体。您可以使用disable_encoding 选项来防止这种情况。要手动解码已编码的响应体，您可以进行以下操作：

from seleniumwire.utils import decode

body = decode(response.body, response.headers.get('Content-Encoding', 'identity'))

date

响应接收的日期时间。

headers

一个类似于字典的响应头对象。头名称不区分大小写，允许重复。请求response.headers['content-length']将返回Content-Length头的值。如果您想替换一个头，请确保先使用del response.headers['header-name']删除现有头，否则您将创建一个重复项。

原因

原因短语，例如OK或Not Found等。

status_code

响应的状态码，例如200或404等。

截获请求和响应

除了捕获请求和响应之外，Selenium Wire 还允许您使用拦截器动态修改它们。拦截器是一个在请求和响应通过 Selenium Wire 时被调用的函数。在拦截器内部，您可以按需修改请求和响应。

您在使用驱动程序之前使用driver.request_interceptor和driver.response_interceptor属性设置您的拦截器函数。请求拦截器应接受一个参数，即请求。响应拦截器应接受两个参数，一个用于原始请求，一个用于响应。

def interceptor(request):
    request.headers['New-Header'] = 'Some Value'

driver.request_interceptor = interceptor
driver.get(...)

# All requests will now contain New-Header

def interceptor(request):
    del request.headers['Referer']  # Remember to delete the header first
    request.headers['Referer'] = 'some_referer'  # Spoof the referer

driver.request_interceptor = interceptor
driver.get(...)

# All requests will now use 'some_referer' for the referer

def interceptor(request, response):  # A response interceptor takes two args
    if request.url == 'https://server.com/some/path':
        response.headers['New-Header'] = 'Some Value'

driver.response_interceptor = interceptor
driver.get(...)

# Responses from https://server.com/some/path will now contain New-Header

def interceptor(request):
    params = request.params
    params['foo'] = 'bar'
    request.params = params

driver.request_interceptor = interceptor
driver.get(...)

# foo=bar will be added to all requests

import json

def interceptor(request):
    if request.method == 'POST' and request.headers['Content-Type'] == 'application/json':
        # The body is in bytes so convert to a string
        body = request.body.decode('utf-8')
        # Load the JSON
        data = json.loads(body)
        # Add a new property
        data['foo'] = 'bar'
        # Set the JSON back on the request
        request.body = json.dumps(data).encode('utf-8')
        # Update the content length
        del request.headers['Content-Length']
        request.headers['Content-Length'] = str(len(request.body))

driver.request_interceptor = interceptor
driver.get(...)

import base64

auth = (
    base64.encodebytes('my_username:my_password'.encode())
    .decode()
    .strip()
)

def interceptor(request):
    if request.host == 'host_that_needs_auth':
        request.headers['Authorization'] = f'Basic {auth}'

driver.request_interceptor = interceptor
driver.get(...)

# Credentials will be transmitted with every request to "host_that_needs_auth"

def interceptor(request):
    # Block PNG, JPEG and GIF images
    if request.path.endswith(('.png', '.jpg', '.gif')):
        request.abort()

driver.request_interceptor = interceptor
driver.get(...)

# Requests for PNG, JPEG and GIF images will result in a 403 Forbidden

def interceptor(request):
    if request.url == 'https://server.com/some/path':
        request.create_response(
            status_code=200,
            headers={'Content-Type': 'text/html'},  # Optional headers dictionary
            body='<html>Hello World!</html>'  # Optional body
        )

driver.request_interceptor = interceptor
driver.get(...)

# Requests to https://server.com/some/path will have their responses mocked

del driver.request_interceptor
del driver.response_interceptor

限制请求捕获

Selenium Wire 通过将浏览器流量通过它后台启动的内部代理服务器进行重定向来工作。当请求通过代理流动时，它们会被拦截和捕获。捕获请求可能会稍微减慢速度，但您可以通过做一些事情来限制要捕获的内容。

driver.scopes

此功能接受一组正则表达式列表，用于匹配要捕获的URL。应在发出请求之前在驱动程序上设置。如果为空（默认值），则捕获所有URL。

driver.scopes = [
    '.*stackoverflow.*',
    '.*github.*'
]

driver.get(...)  # Start making requests

# Only request URLs containing "stackoverflow" or "github" will now be captured

请注意，即使请求超出了范围且未被捕获，它也会通过Selenium Wire传输。

selemiwire_options.disable_capture

使用此选项关闭请求捕获。请求仍然会通过Selenium Wire和任何配置的上游代理，但不会截获或存储。请求拦截器将不会执行。

options = {
    'disable_capture': True  # Don't intercept/store any requests
}
driver = webdriver.Chrome(seleniumwire_options=options)

selemiwire_options.exclude_hosts

使用此选项完全绕过Selenium Wire。对列在此处的地址发出的任何请求将直接从浏览器发送到服务器，而不涉及Selenium Wire。请注意，如果您已配置上游代理，则这些请求也将绕过该代理。

options = {
    'exclude_hosts': ['host1.com', 'host2.com']  # Bypass Selenium Wire for these hosts
}
driver = webdriver.Chrome(seleniumwire_options=options)

request.abort()

您可以在请求拦截器中使用 request.abort() 早期终止请求。这将立即向客户端发送响应，而无需请求进一步传输。您可以使用此机制来阻止某些类型的请求（例如图片）以提高页面加载性能。

def interceptor(request):
    # Block PNG, JPEG and GIF images
    if request.path.endswith(('.png', '.jpg', '.gif')):
        request.abort()

driver.request_interceptor = interceptor

driver.get(...)  # Start making requests

请求存储

默认情况下，捕获的请求和响应存储在系统临时文件夹中（Linux上是/tmp，Windows上通常是C:\Users\<username>\AppData\Local\Temp）的名为.seleniumwire的子文件夹中。要更改创建.seleniumwire文件夹的位置，可以使用request_storage_base_dir选项。

options = {
    'request_storage_base_dir': '/my/storage/folder'  # .seleniumwire will get created here
}
driver = webdriver.Chrome(seleniumwire_options=options)

options = {
    'request_storage': 'memory'  # Store requests and responses in memory only
}
driver = webdriver.Chrome(seleniumwire_options=options)

options = {
    'request_storage': 'memory',
    'request_storage_max_size': 100  # Store no more than 100 requests in memory
}
driver = webdriver.Chrome(seleniumwire_options=options)

代理

如果您访问的网站位于代理服务器后面，您可以在传递给webdriver的选项中告知Selenium Wire有关该代理服务器。

配置采用以下格式

options = {
    'proxy': {
        'http': 'http://192.168.10.100:8888',
        'https': 'https://192.168.10.100:8888',
        'no_proxy': 'localhost,127.0.0.1'
    }
}
driver = webdriver.Chrome(seleniumwire_options=options)

要使用HTTP基本身份验证与代理一起使用，请在URL中指定用户名和密码

options = {
    'proxy': {
        'https': 'https://user:pass@192.168.10.100:8888',
    }
}

对于除基本身份验证之外的身份验证，您可以使用custom_authorization选项提供Proxy-Authorization头的完整值。例如，如果您的代理使用Bearer方案

options = {
    'proxy': {
        'https': 'https://192.168.10.100:8888',  # No username or password used
        'custom_authorization': 'Bearer mytoken123'  # Custom Proxy-Authorization header value
    }
}

关于Proxy-Authorization头的更多信息，请参见此处。

代理配置也可以通过名为HTTP_PROXY、HTTPS_PROXY和NO_PROXY的环境变量加载。

$ export HTTP_PROXY="http://192.168.10.100:8888"
$ export HTTPS_PROXY="https://192.168.10.100:8888"
$ export NO_PROXY="localhost,127.0.0.1"

options = {
    'proxy': {
        'http': 'socks5://user:pass@192.168.10.100:8888',
        'https': 'socks5://user:pass@192.168.10.100:8888',
        'no_proxy': 'localhost,127.0.0.1'
    }
}
driver = webdriver.Chrome(seleniumwire_options=options)

driver.get(...)  # Using some initial proxy

# Change the proxy
driver.proxy = {
    'https': 'https://user:pass@192.168.10.100:8888',
}

driver.get(...)  # These requests will use the new proxy

机器人检测

如果 Selenium Wire 在您的环境中找到它，则会与 undetected-chromedriver 集成。此库将透明地修改 ChromeDriver，以防止它在网站上触发反爬虫措施。

如果您想利用这一点，请确保已安装 undetected_chromedriver。

pip install undetected-chromedriver

然后在您的代码中，导入 seleniumwire.undetected_chromedriver 包。

import seleniumwire.undetected_chromedriver as uc

chrome_options = uc.ChromeOptions()

driver = uc.Chrome(
    options=chrome_options,
    seleniumwire_options={}
)

证书

Selenium Wire 使用它自己的根证书来解密 HTTPS 流量。通常浏览器不需要信任此证书，因为 Selenium Wire 会告诉浏览器将其添加为例外。这将允许浏览器正常运行，但地址栏中会显示“不安全”消息（以及/或未锁定的锁形标志）。如果您想消除此消息，可以手动安装根证书。

您可以从 这里 下载根证书。下载后，导航到浏览器设置中的“证书”，并在“受信任的根证书颁发机构”部分导入证书。

所有选项

以下是可以通过 seleniumwire_options 驱动器属性传递给 Selenium Wire 的所有选项的摘要。

addr

运行 Selenium Wire 的机器的 IP 地址或主机名。默认为 127.0.0.1。如果您正在使用 远程 WebDriver，可能需要将其更改为机器（或容器）的公共 IP 地址。

options = {
    'addr': '192.168.0.10'  # Use the public IP of the machine
}
driver = webdriver.Chrome(seleniumwire_options=options)

auto_config

Selenium Wire 是否应该自动配置浏览器以捕获请求。默认值为 True。

ca_cert

如果更喜欢使用自己的证书而不是默认证书，请提供根（CA）证书的路径。

options = {
    'ca_cert': '/path/to/ca.crt'  # Use own root certificate
}
driver = webdriver.Chrome(seleniumwire_options=options)

ca_key

如果使用自己的根证书，请提供私钥的路径。始终在使用自己的证书时提供此密钥。

options = {
    'ca_key': '/path/to/ca.key'  # Path to private key
}
driver = webdriver.Chrome(seleniumwire_options=options)

disable_capture

禁用请求捕获。当 True 时，不会拦截或存储任何内容。默认值为 False。

options = {
    'disable_capture': True  # Don't intercept/store any requests.
}
driver = webdriver.Chrome(seleniumwire_options=options)

disable_encoding

请求服务器发送未压缩的数据。默认值为 False。当 True 时，此选项将所有出站请求的 Accept-Encoding 标头设置为 identity。请注意，它可能并不总是有效 - 有时服务器可能会忽略它。

options = {
    'disable_encoding': True  # Ask the server not to compress the response
}
driver = webdriver.Chrome(seleniumwire_options=options)

enable_har

当 True 时，将保留 HTTP 交易的 HAR 归档，可以使用 driver.har 获取。默认值为 False。

options = {
    'enable_har': True  # Capture HAR data, retrieve with driver.har
}
driver = webdriver.Chrome(seleniumwire_options=options)

exclude_hosts

应完全绕过Selenium Wire的地址列表。注意，如果您已配置上游代理，则排除的主机请求也将绕过该代理。

options = {
    'exclude_hosts': ['google-analytics.com']  # Bypass these hosts
}
driver = webdriver.Chrome(seleniumwire_options=options)

ignore_http_methods

应忽略并捕获的HTTP方法列表（指定为大写字符串）。默认为['OPTIONS']，忽略所有OPTIONS请求。要捕获所有请求方法，将ignore_http_methods设置为空列表。

options = {
    'ignore_http_methods': []  # Capture all requests, including OPTIONS requests
}
driver = webdriver.Chrome(seleniumwire_options=options)

port

Selenium Wire后端监听的端口号。通常不需要指定端口号，因为会自动选择一个随机端口号。

options = {
    'port': 9999  # Tell the backend to listen on port 9999 (not normally necessary to set this)
}
driver = webdriver.Chrome(seleniumwire_options=options)

proxy

如果您使用代理，则提供上游代理服务器配置。

options = {
    'proxy': {
        'http': 'http://user:pass@192.168.10.100:8888',
        'https': 'https://user:pass@192.168.10.100:8889',
        'no_proxy': 'localhost,127.0.0.1'
    }
}
driver = webdriver.Chrome(seleniumwire_options=options)

request_storage

要使用的存储类型。Selenium Wire默认使用基于磁盘的存储，但可以通过设置此选项为memory来切换到内存存储。

options = {
    'request_storage': 'memory'  # Store requests and responses in memory only
}
driver = webdriver.Chrome(seleniumwire_options=options)

request_storage_base_dir

当使用默认基于磁盘的存储时，Selenium Wire存储捕获的请求和响应的基础位置。默认为系统临时文件夹（Linux上的/tmp和Windows上的通常为C:\Users\<username>\AppData\Local\Temp）。将创建一个名为.seleniumwire的子文件夹来存储捕获的数据。

options = {
    'request_storage_base_dir': '/my/storage/folder'  # .seleniumwire will get created here
}
driver = webdriver.Chrome(seleniumwire_options=options)

request_storage_max_size

使用内存存储时存储请求的最大数量。默认为无限。此选项在默认基于磁盘的存储中目前没有效果。

options = {
    'request_storage': 'memory',
    'request_storage_max_size': 100  # Store no more than 100 requests in memory
}
driver = webdriver.Chrome(seleniumwire_options=options)

suppress_connection_errors

是否抑制与连接相关的回溯。默认为True，意味着有时在浏览器关闭时发生的无害错误不会引起用户警觉。当被抑制时，连接错误消息将在DEBUG级别记录，不带回溯。将此设置为False以允许异常传播并查看完整的回溯。

options = {
    'suppress_connection_errors': False  # Show full tracebacks for any connection errors
}
driver = webdriver.Chrome(seleniumwire_options=options)

verify_ssl

是否应验证SSL证书。默认为False，这防止了与自签名证书相关的错误。

options = {
    'verify_ssl': True  # Verify SSL certificates but beware of errors with self-signed certificates
}
driver = webdriver.Chrome(seleniumwire_options=options)

许可证

MIT

历史记录