Selenium Wire

https://github.com/wkeeling/selenium-wire
Admin
Selenium Wire is a proxy for Selenium that allows you to inspect and modify network requests and...
Tokens:13,477
Snippets:98
Trust Score:8.4
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Selenium Wire using pip

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This command installs the Selenium Wire package using pip. It's the standard method for Python package installation. Ensure pip is up-to-date for potential build issues.

```bash
pip install selenium-wire
```

--------------------------------

### Set up Virtual Environment and Install

Source: https://github.com/wkeeling/selenium-wire/blob/master/CONTRIBUTING.rst

Sets up a virtual environment named 'selenium-wire' and installs the local copy of the project in development mode using `setup.py develop`. This ensures that changes made locally are reflected immediately.

```shell
mkvirtualenv selenium-wire
cd selenium-wire/
python setup.py develop
```

--------------------------------

### Install undetected-chromedriver (Bash)

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Provides the command to install the 'undetected-chromedriver' package, which Selenium Wire can integrate with to bypass bot detection mechanisms on websites.

```bash
pip install undetected-chromedriver
```

--------------------------------

### Install OpenSSL on Alpine Linux

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This command installs the OpenSSL package on Alpine Linux using the apk package manager. OpenSSL is a dependency for Selenium Wire to decrypt HTTPS requests.

```bash
sudo apk add openssl
```

--------------------------------

### Install OpenSSL on macOS using Homebrew

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This command installs OpenSSL on macOS using the Homebrew package manager. OpenSSL is a dependency for Selenium Wire to decrypt HTTPS requests.

```bash
brew install openssl
```

--------------------------------

### Install OpenSSL on Debian/Ubuntu

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This command installs the OpenSSL package on Debian-based Linux systems using the apt package manager. OpenSSL is a dependency for Selenium Wire to decrypt HTTPS requests.

```bash
sudo apt install openssl
```

--------------------------------

### Import WebDriver from Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This snippet shows the initial import required to use Selenium Wire's webdriver functionalities. It highlights importing 'webdriver' from the 'seleniumwire' package, which is the starting point for using its extended capabilities.

```python
from seleniumwire import webdriver
```

--------------------------------

### Install OpenSSL on Fedora/CentOS/RHEL

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This command installs the OpenSSL package on RPM-based Linux systems using the yum package manager. OpenSSL is a dependency for Selenium Wire to decrypt HTTPS requests.

```bash
sudo yum install openssl
```

--------------------------------

### Initialize Chrome WebDriver with Selenium Wire

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Initializes a Chrome browser instance using Selenium Wire, allowing for the capture and inspection of HTTP traffic. This example shows basic usage and advanced configuration with Chrome-specific and Selenium Wire options, including proxy settings and request storage.

```python
from seleniumwire import webdriver

# Basic usage with default options
driver = webdriver.Chrome()

# With Chrome-specific options and Selenium Wire options
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')

seleniumwire_options = {
    'proxy': {
        'http': 'http://192.168.10.100:8888',
        'https': 'https://192.168.10.100:8888',
        'no_proxy': 'localhost,127.0.0.1'
    },
    'disable_encoding': True,
    'request_storage': 'memory',
    'request_storage_max_size': 100
}

driver = webdriver.Chrome(
    options=chrome_options,
    seleniumwire_options=seleniumwire_options
)

driver.get('https://www.example.com')
driver.quit()
```

--------------------------------

### Configure SOCKS Proxy (Python)

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Illustrates how to configure SOCKS proxies (socks5, socks4, socks5h) within Selenium Wire. It includes examples for both authenticated and unauthenticated SOCKS proxies.

```python
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)
```

--------------------------------

### Inspect HTTP Request and Response Details

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Provides detailed access to attributes of HTTP requests and responses captured by Selenium Wire. This snippet shows how to inspect elements like URL, method, headers, body, query parameters, and response status codes. It also includes an example of decoding a compressed response body.

```python
from seleniumwire import webdriver
from seleniumwire.utils import decode

driver = webdriver.Chrome()
driver.get('https://httpbin.org/post')

request = driver.last_request

# Request attributes
print(f"URL: {request.url}")
print(f"Method: {request.method}")
print(f"Host: {request.host}")
print(f"Path: {request.path}")
print(f"Query string: {request.querystring}")
print(f"Headers: {dict(request.headers)}")
print(f"Body: {request.body}")
print(f"Date: {request.date}")

# Access request parameters
params = request.params
print(f"Parameters: {params}")

# Response attributes
if request.response:
    response = request.response
    print(f"Status code: {response.status_code}")
    print(f"Reason: {response.reason}")
    print(f"Headers: {dict(response.headers)}")

    # Decode compressed response body
    encoding = response.headers.get('Content-Encoding', 'identity')
    body = decode(response.body, encoding)
    print(f"Decoded body: {body}")

# SSL certificate info
print(f"Certificate: {request.cert}")

driver.quit()
```

--------------------------------

### Wait for a Specific Request using Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Provides an example of using `driver.wait_for_request()` to pause execution until a specific HTTP request is captured. This is useful for synchronizing actions after a user interaction, like clicking a button that triggers an AJAX call.

```python
# 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/')
```

--------------------------------

### Add Request Header using Interceptor in Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This example shows how to add a custom header to all outgoing requests using a request interceptor. The interceptor function modifies the `request.headers` dictionary before the request is sent.

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

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

--------------------------------

### Webdriver Instantiation

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Demonstrates how to import and instantiate the webdriver from selenium-wire, including options for browser-specific settings and selenium-wire options.

```APIDOC
## Webdriver Instantiation

### Description
Import and instantiate the webdriver from the `seleniumwire` package. You can pass browser-specific options and `seleniumwire_options`.

### Method
`webdriver.Chrome()` or `webdriver.Remote()`

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from seleniumwire import webdriver

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

# Or create using browser specific options and/or seleniumwire_options options
chrome_options = webdriver.ChromeOptions()
# Configure chrome_options here

selenium_wire_options = {
    'some_option': 'some_value'
}

driver = webdriver.Chrome(
    options=chrome_options,
    seleniumwire_options=selenium_wire_options
)

# Remote Webdriver Example
remote_options = {
    'addr': 'hostname_or_ip'
}
driver = webdriver.Remote(
    command_executor='http://www.example.com',
    seleniumwire_options=remote_options
)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Basic Selenium Wire Usage in Python

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This snippet demonstrates how to initialize a Selenium Wire webdriver, navigate to a URL, and iterate through captured requests to print their URLs, status codes, and content types. It requires the 'selenium-wire' package and a compatible webdriver.

```python
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']
        )
```

--------------------------------

### Version Bumping and Deployment

Source: https://github.com/wkeeling/selenium-wire/blob/master/CONTRIBUTING.rst

Provides commands for maintainers to bump the version of the project (patch, minor, or major), push changes and tags, and trigger an automated deployment to PyPI via Travis CI.

```shell
bumpversion patch # possible: major / minor / patch
git push
git push --tags
```

--------------------------------

### Instantiate Chrome WebDriver with Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Demonstrates how to instantiate the Chrome WebDriver using Selenium Wire. It shows options for creating a driver with default settings or with custom browser-specific options and Selenium Wire specific options.

```python
# 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={...}
)
```

--------------------------------

### Run Linters and Tests

Source: https://github.com/wkeeling/selenium-wire/blob/master/CONTRIBUTING.rst

Executes linting with flake8 and runs tests using `setup.py test` or `py.test`. It also includes instructions for testing across different Python versions using `tox`. These steps ensure code quality and compatibility.

```shell
flake8 seleniumwire tests
python setup.py test or py.test
tox
```

--------------------------------

### Clone Selenium Wire Repository

Source: https://github.com/wkeeling/selenium-wire/blob/master/CONTRIBUTING.rst

Clones the Selenium Wire repository from GitHub to your local machine. This is the first step in setting up the project for local development.

```shell
git clone git@github.com:your_name_here/selenium-wire.git
```

--------------------------------

### Set Proxy via Environment Variables (Bash)

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Shows how to configure proxy settings using standard environment variables (HTTP_PROXY, HTTPS_PROXY, NO_PROXY). This is a common method for system-wide or application-level proxy configuration.

```bash
$ 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"
```

--------------------------------

### Configure Firefox WebDriver with Custom Options and Selenium Wire

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Shows how to create a Firefox browser instance with Selenium Wire, including custom Firefox options and Selenium Wire specific configurations like disabling encoding and excluding hosts.

```python
from seleniumwire import webdriver

firefox_options = webdriver.FirefoxOptions()
firefox_options.add_argument('--headless')
firefox_options.set_preference('network.proxy.allow_hijacking_localhost', True)

seleniumwire_options = {
    'disable_encoding': True,
    'exclude_hosts': ['google-analytics.com', 'facebook.net']
}

driver = webdriver.Firefox(
    options=firefox_options,
    seleniumwire_options=seleniumwire_options
)

driver.get('https://www.example.com')

for request in driver.requests:
    print(request.url)

driver.quit()
```

--------------------------------

### Run a Subset of Tests

Source: https://github.com/wkeeling/selenium-wire/blob/master/CONTRIBUTING.rst

Demonstrates how to run a specific subset of tests using Python's `unittest` module. This is useful for quickly verifying changes related to a particular test file.

```shell
python -m unittest tests.test_seleniumwire
```

--------------------------------

### Dynamically Change Proxy Settings with Selenium Wire

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Demonstrates how to dynamically set and clear proxy configurations for a Selenium Wire driver. This is useful for changing proxy settings during a test session. No external dependencies are required beyond Selenium Wire.

```python
from seleniumwire import webdriver

# Initialize driver (assuming Chrome for this example)
driver = webdriver.Chrome()

# Dynamically change proxy settings
driver.proxy = {
    'https': 'https://newuser:newpass@192.168.10.200:9999',
    'no_proxy': 'localhost,127.0.0.1'
}

driver.get('https://www.another-site.com')

# Clear proxy
driver.proxy = {}

driver.quit()
```

--------------------------------

### Configuring Request Storage Directory

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Change the base directory where Selenium Wire creates its `.seleniumwire` storage folder.

```APIDOC
## Request Storage Base Directory

### Description
By default, captured requests and responses are stored in a `.seleniumwire` subfolder within the system's temporary directory. Use the `request_storage_base_dir` option to specify a custom location for this folder.

### Method
Configuration via seleniumwire_options dictionary

### Endpoint
N/A (Driver configuration)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from seleniumwire import webdriver

options = {
    'request_storage_base_dir': '/my/custom/storage/folder' # .seleniumwire will be created here
}
driver = webdriver.Chrome(seleniumwire_options=options)
driver.get('https://www.example.com')
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Configure Upstream Proxies

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Specify upstream proxy servers for Selenium Wire to use. The 'proxy' option accepts a dictionary with 'http', 'https', and 'no_proxy' keys for configuration. Basic authentication can be included in the proxy URL.

```python
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)
```

```python
options = {
    'proxy': {
        'http': 'http://user:pass@192.168.10.100:8888',
        'https': 'http://user:pass@192.168.10.100:8888'
    }
}
driver = webdriver.Chrome(seleniumwire_options=options)
```

--------------------------------

### Import WebDriverWait from Selenium

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Illustrates how to import auxiliary components like WebDriverWait, which are still managed by the base Selenium package even when using Selenium Wire. This is important for functionalities not directly extended by Selenium Wire.

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

--------------------------------

### Request Object Methods

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Details the methods available on a request object when using Selenium Wire.

```APIDOC
## Request Object Methods

### Description
These methods allow for manipulation and termination of requests within interceptors.

### Methods
- **abort(error_code=403)**: Trigger immediate termination of the request with the supplied error code. For use within request interceptors.
- **create_response(status_code, headers=(), body=b'')**: Create a response and return it without sending any data to the remote server. For use within request interceptors.
```

--------------------------------

### Create a New Branch for Development

Source: https://github.com/wkeeling/selenium-wire/blob/master/CONTRIBUTING.rst

Creates a new Git branch for local development, whether for bug fixes or new features. This helps in organizing changes and facilitates pull requests.

```shell
git checkout -b name-of-your-bugfix-or-feature
```

--------------------------------

### Use undetected-chromedriver with Selenium Wire (Python)

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Demonstrates how to import and use the 'undetected_chromedriver' module with Selenium Wire for enhanced stealth capabilities. This allows for a more robust browsing experience against anti-bot systems.

```python
import seleniumwire.undetected_chromedriver as uc

chrome_options = uc.ChromeOptions()

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

--------------------------------

### Configure SOCKS Proxy (including Tor) with Selenium Wire

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Shows how to configure Selenium Wire to use SOCKS proxies, including Tor for anonymized browsing. This requires a running SOCKS proxy server. The input is a dictionary of proxy configurations.

```python
from seleniumwire import webdriver

# Configure SOCKS5 proxy
seleniumwire_options = {
    'proxy': {
        'http': 'socks5://user:pass@192.168.10.100:1080',
        'https': 'socks5://user:pass@192.168.10.100:1080',
        'no_proxy': 'localhost,127.0.0.1'
    }
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)

# For Tor (default Tor SOCKS port is 9050)
tor_options = {
    'proxy': {
        'http': 'socks5://127.0.0.1:9050',
        'https': 'socks5://127.0.0.1:9050'
    }
}

tor_driver = webdriver.Chrome(seleniumwire_options=tor_options)
tor_driver.get('https://check.torproject.org')

driver.quit()
tor_driver.quit()
```

--------------------------------

### Commit and Push Changes

Source: https://github.com/wkeeling/selenium-wire/blob/master/CONTRIBUTING.rst

Stages all changes, commits them with a descriptive message, and pushes the branch to the remote GitHub repository. This is a standard workflow for submitting code changes.

```shell
git add .
git commit -m "Your detailed description of your changes."
git push origin name-of-your-bugfix-or-feature
```

--------------------------------

### Configure Custom Proxy Authorization (Python)

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Demonstrates how to set a custom 'Proxy-Authorization' header for authentication schemes other than Basic. This is useful for proxies that use token-based authentication like Bearer.

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

--------------------------------

### Configuring Upstream Proxies

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Configure Selenium Wire to use an upstream proxy server for network requests.

```APIDOC
## Configure Upstream Proxies

### Description
If the target site is behind a proxy server, you can configure Selenium Wire to use it. The proxy settings include URLs for HTTP, HTTPS, and a list of hosts to bypass (no_proxy).

### Method
Configuration via seleniumwire_options dictionary

### Endpoint
N/A (Driver configuration)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from seleniumwire import webdriver

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)
driver.get('https://www.example.com')

# Using HTTP Basic Auth with proxy
options_with_auth = {
    'proxy': {
        'http': 'http://user:password@192.168.10.100:8888',
        'https': 'https://user:password@192.168.10.100:8888'
    }
}
driver_auth = webdriver.Chrome(seleniumwire_options=options_with_auth)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Configure Upstream Proxy for Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Sets up an upstream proxy server for Selenium Wire to route network requests through. This configuration includes details for HTTP, HTTPS, and hosts that should not use the proxy.

```python
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)
```

--------------------------------

### Python: Block Request

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Demonstrates how to block an incoming HTTP request and return an immediate response using Selenium Wire's `request.abort()`. An optional error code can be provided; the default is 403.

```python
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
```

--------------------------------

### Python: Add Basic Authentication Header

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Shows how to add basic authentication credentials to requests for a specific host using Selenium Wire. This prevents the browser's authentication pop-up. Requires base64 encoding of the username and password.

```python
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"
```

--------------------------------

### Configure In-Memory Storage with Selenium Wire

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Demonstrates how to configure Selenium Wire to store captured requests in memory instead of on disk, which is useful for short-lived containers. The configuration includes a maximum size for the in-memory storage.

```python
from seleniumwire import webdriver

# Configure in-memory storage with size limit
seleniumwire_options = {
    'request_storage': 'memory',
    'request_storage_max_size': 100  # Store max 100 requests
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get('https://www.example.com')

# Requests are stored in memory only
print(f"Captured {len(driver.requests)} requests")

# Older requests are discarded when limit is reached
driver.quit()
```

--------------------------------

### Python: Mock Response

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Illustrates how to mock an HTTP response using Selenium Wire's `request.create_response()`. This allows sending a custom reply to the browser without sending any data to the remote server.

```python
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
```

--------------------------------

### Configure Custom SSL Certificates with Selenium Wire

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Explains how to use custom SSL certificates for HTTPS interception with Selenium Wire. This requires specifying the paths to the custom certificate and key files.

```python
from seleniumwire import webdriver

# Specify custom certificate and key
seleniumwire_options = {
    'ca_cert': '/path/to/custom-ca.crt',
    'ca_key': '/path/to/custom-ca.key'
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get('https://www.example.com')

# Requests will be intercepted using the custom certificate
driver.quit()
```

--------------------------------

### Python: Configure Upstream Proxies

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Sets up Selenium Wire to route browser traffic through an upstream proxy server. This is useful for network analysis, security testing, or accessing resources through a specific network gateway. Requires selenium-wire.

```python
from seleniumwire import webdriver

# Configure upstream proxy
seleniumwire_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=seleniumwire_options)
driver.get('https://www.example.com')

```

--------------------------------

### Intercepting Requests and Responses

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Information on how to use request and response interceptors in Selenium Wire to modify traffic on the fly.

```APIDOC
## Intercepting Requests and Responses

### Description
Selenium Wire allows modification of requests and responses in real-time using interceptor functions. These functions are invoked as traffic passes through Selenium Wire.

### Setting Interceptors
Set interceptor functions using the `driver.request_interceptor` and `driver.response_interceptor` attributes before initiating driver actions.

- **Request Interceptor**: Accepts a single argument: the request object.
- **Response Interceptor**: Accepts two arguments: the originating request object and the response object.

### Example: Add a Request Header

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

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

# All requests will now contain New-Header
```

### Example: Replace an Existing Request Header

```python
def interceptor(request):
    # Delete the existing header first to avoid duplicates
    if 'Existing-Header' in request.headers:
        del request.headers['Existing-Header']
    request.headers['New-Header'] = 'New Value'

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

--------------------------------

### Configuring Scopes

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Limit captured requests to URLs matching specified regular expressions.

```APIDOC
## Configure URL Scopes

### Description
This feature allows you to specify a list of regular expressions that will be used to filter which URLs are captured. Only URLs matching these patterns will be intercepted and stored. If the list is empty (default), all URLs are captured.

### Method
Configuration via driver attribute

### Endpoint
N/A (Driver configuration)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from seleniumwire import webdriver

# Configure scopes to capture only stackoverflow and github URLs
driver = webdriver.Chrome()
driver.scopes = [
    '.*stackoverflow.*',
    '.*github.*'
]

driver.get('https://www.example.com') # Requests not matching scopes will not be captured
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Configure Remote WebDriver with Selenium Wire

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Demonstrates how to configure Selenium Wire for remote WebDriver instances, specifying the address and port of the machine running Selenium Wire. This is useful when Selenium Grid or a standalone remote server is used.

```python
from seleniumwire import webdriver

# Specify the address of the machine running Selenium Wire
seleniumwire_options = {
    'addr': '192.168.1.100',  # IP address of machine running Selenium Wire
    'port': 9999  # Optional: specify port
}

driver = webdriver.Remote(
    command_executor='http://selenium-hub:4444/wd/hub',
    seleniumwire_options=seleniumwire_options
)

driver.get('https://www.example.com')

# Access requests as normal
for request in driver.requests:
    print(request.url)

driver.quit()
```

--------------------------------

### Python: Mock API and HTML Responses with Request Interceptor

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Intercepts network requests to provide mock responses for specific URLs, bypassing actual server calls. Useful for testing frontend applications without backend dependencies. Requires the selenium-wire library.

```python
from seleniumwire import webdriver

def request_interceptor(request):
    # Mock API endpoint response
    if request.url == 'https://api.example.com/users':
        request.create_response(
            status_code=200,
            headers={'Content-Type': 'application/json'},
            body='{"users": [{"id": 1, "name": "Mock User"}]}'.encode('utf-8')
        )
        return

    # Mock HTML response
    if 'mock-page' in request.url:
        html_content = '''
        <html>
            <head><title>Mocked Page</title></head>
            <body><h1>This is a mocked response</h1></body>
        </html>
        '''
        request.create_response(
            status_code=200,
            headers={'Content-Type': 'text/html'},
            body=html_content.encode('utf-8')
        )
        return

driver = webdriver.Chrome()
driver.request_interceptor = request_interceptor

driver.get('https://api.example.com/users')

# Verify mock response was used
request = driver.last_request
print(f"Response body: {request.response.body}")

driver.quit()
```

--------------------------------

### Configure Remote WebDriver with Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Shows how to configure the remote WebDriver client in Selenium Wire. It specifies the need to set the 'addr' option to the hostname or IP address of the machine running Selenium Wire for proper communication.

```python
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
)
```

--------------------------------

### Configure CA Certificate for Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Specifies the path to a custom root CA certificate for Selenium Wire to use, allowing for custom certificate management. This is useful when you need to use your own certificate infrastructure.

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

--------------------------------

### Configure Custom IP Address for Selenium Wire (Python)

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Shows how to specify a custom IP address or hostname for the Selenium Wire process using the 'addr' option. This is particularly useful when running Selenium Wire in a remote or containerized environment.

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

--------------------------------

### Dynamically Change Proxy Settings (Python)

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Explains how to modify the proxy settings of an existing Selenium Wire WebDriver instance by assigning a new dictionary to the `driver.proxy` attribute. This allows for on-the-fly proxy changes.

```python
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
```

--------------------------------

### Configure CA Key for Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Provides the path to the private key associated with a custom root CA certificate. This key must always be supplied when a custom certificate is used for request interception.

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

--------------------------------

### Configure Backend Port for Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Sets the specific port number on which Selenium Wire's backend service will listen for connections. Typically, a random port is chosen automatically, so manual configuration is usually not required.

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

--------------------------------

### Request Object Attributes

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Lists and describes the attributes available on captured request objects, such as `body`, `cert`, `date`, and `headers`.

```APIDOC
## Request Object Attributes

### Description
Request objects captured by selenium-wire have several attributes providing details about the HTTP request.

### Method
Attribute access on a request object

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Assuming 'request' is a captured request object

request_body = request.body  # bytes
server_cert = request.cert  # dict or empty
request_date = request.date  # datetime object
request_headers = request.headers  # dict
request_method = request.method # str (e.g., 'GET', 'POST')
request_url = request.url # str
```

### Response
#### Success Response (200)
- **body** (bytes) - The request body. Empty if no body.
- **cert** (dict) - SSL certificate information for HTTPS requests. Empty otherwise.
- **date** (datetime) - The datetime the request was made.
- **headers** (dict) - The request headers.
- **method** (str) - The HTTP method used for the request.
- **url** (str) - The URL of the request.

#### Response Example
N/A
```

--------------------------------

### Response Object Attributes

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Details the attributes available on a response object when using Selenium Wire.

```APIDIDOC
## Response Object Attributes

### Description
These attributes provide access to various components of an HTTP response.

### Attributes
- **body** (bytes) - The response body as `bytes`. Can be empty if the response has no body. May be compressed.
- **date** (datetime) - The datetime the response was received.
- **headers** (dict-like) - A dictionary-like object of response headers. Headers are case-insensitive and duplicates are permitted.
- **reason** (str) - The reason phrase, e.g. `OK` or `Not Found` etc.
- **status_code** (int) - The status code of the response, e.g. `200` or `404` etc.
```

--------------------------------

### Accessing Captured Requests

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Explains how to access captured HTTP/HTTPS requests using attributes like `driver.requests`, `driver.last_request`, and methods like `driver.wait_for_request()`.

```APIDOC
## Accessing Captured Requests

### Description
Selenium Wire captures all HTTP/HTTPS traffic made by the browser. Access requests via `driver.requests`, `driver.last_request`, and use `driver.wait_for_request()` to wait for specific requests.

### Method
Attribute access and method call on webdriver instance

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Access all captured requests
all_requests = driver.requests

# Access the last captured request
last_request = driver.last_request

# Wait for a request matching a pattern (substring or regex)
try:
    request = driver.wait_for_request('/api/products/12345/', timeout=10)
    print(f"Found request: {request.url}")
except TimeoutException:
    print("Request not found within timeout")

# Iterate over captured requests
for req in driver.iter_requests():
    print(req.url)

# Get HAR archive (ensure enable_har is True in options)
har_data = driver.har
```

### Response
#### Success Response (200)
- **requests** (list) - List of captured request objects in chronological order.
- **last_request** (object) - The most recently captured request object.
- **wait_for_request()** (object) - The first request object matching the pattern.
- **har** (dict) - A JSON formatted HAR archive.

#### Response Example
N/A
```

--------------------------------

### Python: Add Request Parameter

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Illustrates how to add a parameter to an HTTP request using Selenium Wire. Request parameters need to be read, updated, and then written back to the request object.

```python
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
```

--------------------------------

### Request Object Attributes

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Details the attributes available on a request object when using Selenium Wire.

```APIDOC
## Request Object Attributes

### Description
These attributes provide access to various components of an HTTP request.

### Attributes
- **headers** (dict-like) - A dictionary-like object of request headers. Headers are case-insensitive and duplicates are permitted.
- **host** (str) - The request host, e.g. `www.example.com`
- **method** (str) - The HTTP method, e.g. `GET` or `POST` etc.
- **params** (dict) - A dictionary of request parameters. If a parameter with the same name appears more than once in the request, its value in the dictionary will be a list.
- **path** (str) - The request path, e.g. `/some/path/index.html`
- **querystring** (str) - The query string, e.g. `foo=bar&spam=eggs`
- **response** (object or None) - The `response object`_ associated with the request. This will be `None` if the request has no response.
- **url** (str) - The request URL, e.g. `https://www.example.com/some/path/index.html?foo=bar&spam=eggs`
- **ws_messages** (list) - If the request is a websocket handshake request, this will contain a list of any websocket messages sent and received.
```

--------------------------------

### Enable HAR Archive Generation in Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Enables the creation of a HAR (HTTP Archive) file containing all HTTP transactions. The HAR data can be later retrieved using the `driver.har` attribute.

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

--------------------------------

### Python: Delete and Set Request Header

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Demonstrates how to delete an existing header and set a new one in an HTTP request using Selenium Wire's request interceptor. This is useful for spoofing headers like 'Referer'.

```python
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
```

--------------------------------

### Capture Specific URLs with driver.scopes

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Configure Selenium Wire to capture only URLs matching specified regular expressions. Set this option on the driver before making requests. If empty, all URLs are captured. Requests out of scope still pass through Selenium Wire.

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

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

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

--------------------------------

### Python: Generate HTTP Archive (HAR) Data

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Enables the capture of network traffic in the standard HTTP Archive (HAR) format, facilitating detailed network performance analysis. The captured data can be saved to a file. Requires selenium-wire and the 'json' module.

```python
from seleniumwire import webdriver
import json

# Enable HAR capture
seleniumwire_options = {
    'enable_har': True
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get('https://www.example.com')

# Get HAR data as JSON string
har_data = driver.har

# Parse and save to file
har_dict = json.loads(har_data)
with open('network_traffic.har', 'w') as f:
    json.dump(har_dict, f, indent=2)

print(f"Captured {len(har_dict['log']['entries'])} HAR entries")

# HAR data includes timing information
for entry in har_dict['log']['entries']:
    print(f"URL: {entry['request']['url']}")
    print(f"Time: {entry['time']}ms")

driver.quit()
```

--------------------------------

### Configure Request Storage Base Directory

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Change the directory where Selenium Wire stores captured requests and responses by setting the 'request_storage_base_dir' option. The default location is a '.seleniumwire' subfolder in the system's temporary directory.

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

--------------------------------

### Python: Limit Request Capture with Scopes

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Filters captured network requests based on URL patterns, improving performance by reducing the amount of data processed. Useful for focusing analysis on specific domains or API endpoints. Requires selenium-wire.

```python
from seleniumwire import webdriver

driver = webdriver.Chrome()

# Only capture requests to specific domains
driver.scopes = [
    '.*stackoverflow.*',
    '.*github.*',
    '.*api\.example\.com.*'
]

driver.get('https://stackoverflow.com')
driver.get('https://github.com')

# Only requests matching the scopes will be captured
print(f"Captured {len(driver.requests)} requests")

for request in driver.requests:
    print(request.url)

# Clear scopes to capture all requests again
del driver.scopes

driver.quit()
```

--------------------------------

### Abort Requests with request.abort() in Interceptor

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Implement request interceptors to abort specific requests early using `request.abort()`. This sends an immediate response to the client, blocking the request from proceeding further. Useful for blocking certain file types to improve load times.

```python
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
```

--------------------------------

### Excluding Hosts

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Bypass Selenium Wire entirely for requests made to specific hosts.

```APIDOC
## Exclude Hosts

### Description
Use the `exclude_hosts` option to specify a list of hostnames for which Selenium Wire should be bypassed. Requests to these hosts will go directly to the server, skipping Selenium Wire and any upstream proxy.

### Method
Configuration via seleniumwire_options dictionary

### Endpoint
N/A (Driver configuration)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from seleniumwire import webdriver

options = {
    'exclude_hosts': ['host1.com', 'host2.com']  # Bypass Selenium Wire for these hosts
}
driver = webdriver.Chrome(seleniumwire_options=options)
driver.get('https://host1.com') # This request will bypass Selenium Wire
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Access Captured HTTP/HTTPS Requests

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Retrieves and processes all HTTP/HTTPS requests made by the browser during navigation using Selenium Wire. This snippet demonstrates iterating through captured requests, accessing request details like method, URL, and response status code, and efficiently accessing the last request or clearing the request list.

```python
from seleniumwire import webdriver

driver = webdriver.Chrome()
driver.get('https://www.google.com')

# Access all captured requests
for request in driver.requests:
    if request.response:
        print(
            request.method,
            request.url,
            request.response.status_code,
            request.response.headers.get('Content-Type', 'N/A')
        )

# Access the last request efficiently
last_request = driver.last_request
print(f"Last request: {last_request.url}")

# Iterate over requests (memory efficient for large request lists)
for request in driver.iter_requests():
    print(request.url)

# Clear captured requests
del driver.requests

driver.quit()
```

--------------------------------

### Clearing Captured Requests

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Shows how to clear previously captured requests and HAR entries using the `del` keyword.

```APIDOC
## Clearing Captured Requests

### Description
Clear previously captured requests and HAR entries by using the `del` keyword on `driver.requests`.

### Method
`del` statement

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Clear all captured requests and HAR entries
del driver.requests
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Configure In-Memory Request Storage for Selenium Wire

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Sets Selenium Wire to store captured requests and responses in memory instead of using the default disk-based storage. This is useful for scenarios where disk I/O is a concern.

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

--------------------------------

### Python: Add Response Header

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Shows how to add a custom header to an HTTP response using a response interceptor in Selenium Wire. This is applicable when specific conditions on the request URL are met.

```python
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
```

--------------------------------

### Configure Selenium-Wire: Verify SSL Certificates (Python)

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

This snippet shows how to configure selenium-wire to verify SSL certificates. By default, SSL verification is disabled to prevent issues with self-signed certificates. Setting 'verify_ssl' to True will enable SSL certificate verification.

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

--------------------------------

### Exclude Hosts from Capture with Selenium Wire

Source: https://context7.com/wkeeling/selenium-wire/llms.txt

Shows how to bypass Selenium Wire entirely for specific hosts, preventing them from being captured. This is useful for excluding analytics or tracking domains. The configuration takes a list of hostnames to exclude.

```python
from seleniumwire import webdriver

# Exclude hosts from being captured
seleniumwire_options = {
    'exclude_hosts': [
        'google-analytics.com',
        'facebook.net',
        'cdn.example.com'
    ]
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get('https://www.example.com')

# Requests to excluded hosts bypass Selenium Wire completely
print(f"Captured {len(driver.requests)} requests")

driver.quit()
```

--------------------------------

### Aborting Requests

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Block requests early within a request interceptor to improve performance.

```APIDOC
## Abort Requests

### Description
Within a request interceptor, you can call `request.abort()` to immediately send a response back to the client without the request proceeding further. This is useful for blocking specific types of requests, such as images, to speed up page loading.

### Method
Using a request interceptor function

### Endpoint
N/A (Driver configuration)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from seleniumwire import webdriver

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

driver = webdriver.Chrome()
driver.request_interceptor = interceptor

driver.get('https://www.example.com') # Image requests will be aborted
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### WebSocketMessage Object Attributes

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Details the attributes of WebSocketMessage objects used in Selenium Wire.

```APIDOC
## WebSocketMessage Object Attributes

### Description
These objects represent websocket messages and provide details about their content and transmission.

### Attributes
- **content** (str or bytes) - The message content.
- **date** (datetime) - The datetime of the message.
- **from_client** (bool) - `True` when the message was sent by the client, `False` when sent by the server.
```

--------------------------------

### Enable In-Memory Request Storage

Source: https://github.com/wkeeling/selenium-wire/blob/master/README.rst

Utilize in-memory storage for requests and responses by setting the 'request_storage' option to 'memory'. This is useful for short-lived containers to avoid disk overhead. The 'request_storage_max_size' option can limit memory consumption.

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

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