Struct BrowserContext 

pub struct BrowserContext { /* private fields */ }

Implementations

impl BrowserContext

pub fn new( parent: Arc<dyn ChannelOwner>, type_name: String, guid: Arc<str>, initializer: Value, ) -> Result<Self>

Creates a new BrowserContext from protocol initialization

This is called by the object factory when the server sends a __create__ message for a BrowserContext object.

Arguments

• parent - The parent Browser object
• type_name - The protocol type name (“BrowserContext”)
• guid - The unique identifier for this context
• initializer - The initialization data from the server

Errors

Returns error if initializer is malformed

pub async fn add_init_script(&self, script: &str) -> Result<()>

Adds a script which would be evaluated in one of the following scenarios:

• Whenever a page is created in the browser context or is navigated.
• Whenever a child frame is attached or navigated in any page in the browser context.

The script is evaluated after the document was created but before any of its scripts were run. This is useful to amend the JavaScript environment, e.g. to seed Math.random.

Arguments

• script - Script to be evaluated in all pages in the browser context.

Errors

Returns error if:

• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-add-init-script

pub async fn new_page(&self) -> Result<Page>

Creates a new page in this browser context.

Pages are isolated tabs/windows within a context. Each page starts at “about:blank” and can be navigated independently.

Errors

Returns error if:

• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-new-page

pub fn pages(&self) -> Vec<Page>

Returns all open pages in the context.

This method provides a snapshot of all currently active pages that belong to this browser context instance. Pages created via new_page() and popup pages opened through user interactions are included.

In persistent contexts launched with --app=url, this will include the initial page created automatically by Playwright.

Errors

This method does not return errors. It provides a snapshot of pages at the time of invocation.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-pages

pub fn service_workers(&self) -> Vec<Worker>

Returns all active service workers registered in this browser context.

Service workers are accumulated as they are registered (serviceWorker event). Each call returns a snapshot of the current list.

Note: Testing service workers typically requires HTTPS. In plain HTTP or about:blank contexts this list is empty.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-service-workers

pub fn browser(&self) -> Option<Browser>

Returns the browser instance that owns this context.

Returns None only for contexts created outside of normal browser (e.g., Android or Electron contexts). For both regular contexts and persistent contexts, this returns the owning Browser instance.

Errors

This method does not return errors.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-browser

pub async fn request(&self) -> Result<APIRequestContext>

Returns the APIRequestContext associated with this context.

The APIRequestContext is created automatically by the server for each BrowserContext. It enables performing HTTP requests and is used internally by Route::fetch().

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-request

pub async fn new_cdp_session(&self, page: &Page) -> Result<CDPSession>

Creates a new Chrome DevTools Protocol session for the given page.

CDPSession provides low-level access to the Chrome DevTools Protocol. This method is only available in Chromium-based browsers.

Arguments

• page - The page to create a CDP session for

Errors

Returns error if:

• The browser is not Chromium-based
• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-new-cdp-session

pub async fn tracing(&self) -> Result<Tracing>

Returns the Tracing object for this browser context.

The Tracing object is created automatically by the Playwright server for each BrowserContext. Use it to start and stop trace recording.

Errors

Returns error if no Tracing object is available for this context (rare, should not happen in normal usage).

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-tracing

pub fn clock(&self) -> Clock

Returns the Clock object for this browser context.

The Clock object enables fake timer control — install fake timers, fast-forward time, pause/resume, and set fixed or system time.

page.clock() delegates to this method via the page’s parent context.

See: https://playwright.dev/docs/api/class-clock

pub async fn close(&self) -> Result<()>

Closes the browser context and all its pages.

This is a graceful operation that sends a close command to the context and waits for it to shut down properly.

Errors

Returns error if:

• Context has already been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-close

pub async fn set_default_timeout(&self, timeout: f64)

Sets the default timeout for all operations in this browser context.

This applies to all pages already open in this context as well as pages created subsequently. Pass 0 to disable timeouts.

Arguments

• timeout - Timeout in milliseconds

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-timeout

pub async fn set_default_navigation_timeout(&self, timeout: f64)

Sets the default timeout for navigation operations in this browser context.

This applies to all pages already open in this context as well as pages created subsequently. Pass 0 to disable timeouts.

Arguments

• timeout - Timeout in milliseconds

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-set-default-navigation-timeout

pub async fn pause(&self) -> Result<()>

Pauses the browser context.

This pauses the execution of all pages in the context.

pub async fn storage_state(&self) -> Result<StorageState>

Returns storage state for this browser context.

Contains current cookies and local storage snapshots.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-storage-state

pub async fn set_storage_state(&self, state: StorageState) -> Result<()>

Sets storage state (cookies and local storage) for this browser context in-place.

Clears all existing cookies, then adds cookies from state.cookies. For each origin in state.origins, a temporary page is opened to that origin and its localStorage is restored via JS evaluation, then the page is closed.

This mirrors browserContext.setStorageState() from the JS/Python Playwright APIs. It is useful for restoring authentication state without recreating the context.

Example

use playwright_rs::protocol::{Cookie, StorageState};

// Restore session cookie
let state = StorageState {
    cookies: vec![Cookie {
        name: "session".to_string(),
        value: "token123".to_string(),
        domain: "example.com".to_string(),
        path: "/".to_string(),
        expires: -1.0,
        http_only: true,
        secure: true,
        same_site: Some("Lax".to_string()),
    }],
    origins: vec![],
};
context.set_storage_state(state).await?;

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-set-storage-state

pub fn is_closed(&self) -> bool

Returns whether this browser context has been closed.

Returns true after [close()] has been called on this context, or after the context receives a close event from the server (e.g. when the browser is closed).

Note: this reflects eventual state. If the context was closed by a server-initiated event, is_closed() becomes true only after the “close” event has been received and processed.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-is-closed

pub async fn add_cookies(&self, cookies: &[Cookie]) -> Result<()>

Adds cookies into this browser context.

All pages within this context will have these cookies installed. Cookies can be granularly specified with name, value, url, domain, path, expires, httpOnly, secure, sameSite.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-add-cookies

pub async fn cookies(&self, urls: Option<&[&str]>) -> Result<Vec<Cookie>>

Returns cookies for this browser context, optionally filtered by URLs.

If urls is None or empty, all cookies are returned.

Arguments

• urls - Optional list of URLs to filter cookies by

Errors

Returns error if:

• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-cookies

pub async fn clear_cookies( &self, options: Option<ClearCookiesOptions>, ) -> Result<()>

Clears cookies from this browser context, with optional filters.

When called with no options, all cookies are removed. Use ClearCookiesOptions to filter which cookies to clear by name, domain, or path.

Arguments

• options - Optional filters for which cookies to clear

Errors

Returns error if:

• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-clear-cookies

pub async fn set_extra_http_headers( &self, headers: HashMap<String, String>, ) -> Result<()>

Sets extra HTTP headers that will be sent with every request from this context.

These headers are merged with per-page extra headers set with page.set_extra_http_headers(). If the page has specific headers that conflict, page-level headers take precedence.

Arguments

• headers - Map of header names to values. All header names are lowercased.

Errors

Returns error if:

• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-set-extra-http-headers

pub async fn grant_permissions( &self, permissions: &[&str], options: Option<GrantPermissionsOptions>, ) -> Result<()>

Grants browser permissions to the context.

Permissions are granted for all pages in the context. The optional origin in GrantPermissionsOptions restricts the grant to a specific URL origin.

Common permissions: "geolocation", "notifications", "camera", "microphone", "clipboard-read", "clipboard-write".

Arguments

• permissions - List of permission strings to grant
• options - Optional options, including origin to restrict the grant

Errors

Returns error if:

• Permission name is not recognised
• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-grant-permissions

pub async fn clear_permissions(&self) -> Result<()>

Clears all permission overrides for this browser context.

Reverts all permissions previously set with grant_permissions() back to the browser default state.

Errors

Returns error if:

• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-clear-permissions

pub async fn set_geolocation( &self, geolocation: Option<Geolocation>, ) -> Result<()>

Sets or clears the geolocation for all pages in this context.

Pass Some(Geolocation { ... }) to set a specific location, or None to clear the override and let the browser handle location requests naturally.

Note: Geolocation access requires the "geolocation" permission to be granted via grant_permissions() for navigator.geolocation to succeed.

Arguments

• geolocation - Location to set, or None to clear

Errors

Returns error if:

• Latitude or longitude is out of range
• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-set-geolocation

pub async fn set_offline(&self, offline: bool) -> Result<()>

Toggles the offline mode for this browser context.

When true, all network requests from pages in this context will fail with a network error. Set to false to restore network connectivity.

Arguments

• offline - true to go offline, false to go back online

Errors

Returns error if:

• Context has been closed
• Communication with browser process fails

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-set-offline

pub async fn route<F, Fut>(&self, pattern: &str, handler: F) -> Result<()>

where F: Fn(Route) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Registers a route handler for context-level network interception.

Routes registered on a context apply to all pages within the context. Page-level routes take precedence over context-level routes.

Arguments

• pattern - URL pattern to match (supports glob patterns like “**/*.png”)
• handler - Async closure that handles the route

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-route

pub async fn unroute(&self, pattern: &str) -> Result<()>

Removes route handler(s) matching the given URL pattern.

Arguments

• pattern - URL pattern to remove handlers for

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-unroute

pub async fn unroute_all( &self, _behavior: Option<UnrouteBehavior>, ) -> Result<()>

Removes all registered route handlers.

Arguments

• behavior - Optional behavior for in-flight handlers

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-unroute-all

pub async fn route_from_har( &self, har_path: &str, options: Option<RouteFromHarOptions>, ) -> Result<()>

Replays network requests from a HAR file recorded previously.

Requests matching options.url (or all requests if omitted) will be served from the archive for every page in this context. Unmatched requests are either aborted or passed through depending on options.not_found ("abort" is the default).

Arguments

• har_path - Path to the .har file on disk
• options - Optional settings (url filter, not_found policy, update mode)

Errors

Returns error if:

• har_path does not exist or cannot be read by the Playwright server
• The Playwright server fails to open the archive

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-route-from-har

pub async fn on_page<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(Page) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Adds a listener for the page event.

The handler is called whenever a new page is created in this context, including popup pages opened through user interactions.

Arguments

• handler - Async function that receives the new Page

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-page

pub async fn on_close<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn() -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Adds a listener for the close event.

The handler is called when the browser context is closed.

Arguments

• handler - Async function called with no arguments when the context closes

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-close

pub async fn on_request<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(Request) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Adds a listener for the request event.

The handler fires whenever a request is issued from any page in the context. This is equivalent to subscribing to on_request on each individual page, but covers all current and future pages of the context.

Context-level handlers fire before page-level handlers.

Arguments

• handler - Async function that receives the Request

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request

pub async fn on_request_finished<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(Request) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Adds a listener for the requestFinished event.

The handler fires after the request has been successfully received by the server and a response has been fully downloaded for any page in the context.

Context-level handlers fire before page-level handlers.

Arguments

• handler - Async function that receives the completed Request

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-finished

pub async fn on_request_failed<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(Request) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Adds a listener for the requestFailed event.

The handler fires when a request from any page in the context fails, for example due to a network error or if the server returned an error response.

Context-level handlers fire before page-level handlers.

Arguments

• handler - Async function that receives the failed Request

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-request-failed

pub async fn on_response<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(ResponseObject) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Adds a listener for the response event.

The handler fires whenever a response is received from any page in the context.

Context-level handlers fire before page-level handlers.

Arguments

• handler - Async function that receives the ResponseObject

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-response

pub async fn on_dialog<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(Dialog) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Adds a listener for the dialog event on this browser context.

The handler fires whenever a JavaScript dialog (alert, confirm, prompt, or beforeunload) is triggered from any page in the context. Context-level handlers fire before page-level handlers.

The dialog must be explicitly accepted or dismissed; otherwise the page will freeze waiting for a response.

Arguments

• handler - Async function that receives the Dialog and calls dialog.accept() or dialog.dismiss().

Errors

Returns error if communication with the browser process fails.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-dialog

pub async fn on_console<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(ConsoleMessage) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Registers a context-level console event handler.

The handler fires for any console message emitted by any page in this context. Context-level handlers fire before page-level handlers.

The server only sends console events after the first handler is registered (subscription is managed automatically per context channel).

Arguments

• handler - Async closure that receives the ConsoleMessage

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-console

pub async fn on_weberror<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(WebError) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Registers a context-level handler for uncaught JavaScript exceptions.

The handler fires whenever a page in this context throws an unhandled JavaScript error (i.e. an exception that propagates to window.onerror or an unhandled promise rejection). The WebError passed to the handler contains the error message and an optional back-reference to the originating page.

Arguments

• handler - Async closure that receives a WebError.

Errors

Returns error if communication with the browser process fails.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-web-error

pub async fn on_serviceworker<F, Fut>(&self, handler: F) -> Result<()>

where F: Fn(Worker) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Registers a handler for the serviceWorker event.

The handler is called when a new service worker is registered in the browser context.

Note: Service worker testing typically requires HTTPS and a registered service worker.

Arguments

• handler - Async closure called with the new Worker object

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-service-worker

pub async fn expose_function<F, Fut>( &self, name: &str, callback: F, ) -> Result<()>

where F: Fn(Vec<Value>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Value> + Send + 'static,

Exposes a Rust function to every page in this browser context as window[name] in JavaScript.

When JavaScript code calls window[name](arg1, arg2, …) the Playwright server fires a bindingCall event that invokes callback with the deserialized arguments. The return value of callback is serialized back to JavaScript so the await window[name](…) expression resolves with it.

The binding is injected into every existing page and every new page created in this context.

Arguments

• name – JavaScript identifier that will be available as window[name].
• callback – Async closure called with Vec<serde_json::Value> (the JS arguments) and returning serde_json::Value (the result).

Errors

Returns error if:

• The context has been closed.
• Communication with the browser process fails.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-function

pub async fn expose_binding<F, Fut>( &self, name: &str, callback: F, ) -> Result<()>

where F: Fn(Vec<Value>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Value> + Send + 'static,

Exposes a Rust function to every page in this browser context as window[name] in JavaScript, with needsHandle: true.

Identical to expose_function but the Playwright server passes the first argument as a JSHandle object rather than a plain value. Use this when the JS caller passes complex objects that you want to inspect on the Rust side.

Arguments

• name – JavaScript identifier.
• callback – Async closure with Vec<serde_json::Value> → serde_json::Value.

Errors

Returns error if:

• The context has been closed.
• Communication with the browser process fails.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-expose-binding

pub async fn expect_page( &self, timeout: Option<f64>, ) -> Result<EventWaiter<Page>>

Waits for a new page to be created in this browser context.

Creates a one-shot waiter that resolves when the next page event fires. The waiter must be created before the action that triggers the new page (e.g. new_page() or a user action that opens a popup) to avoid a race condition.

Arguments

• timeout - Timeout in milliseconds. Defaults to 30 000 ms if None.

Errors

Returns crate::error::Error::Timeout if no page is created within the timeout.

Example

// Set up the waiter BEFORE the triggering action
let waiter = context.expect_page(None).await?;
let _page = context.new_page().await?;
let new_page = waiter.wait().await?;

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-wait-for-event

pub async fn expect_close( &self, timeout: Option<f64>, ) -> Result<EventWaiter<()>>

Waits for this browser context to be closed.

Creates a one-shot waiter that resolves when the close event fires. The waiter must be created before the action that closes the context to avoid a race condition.

Arguments

• timeout - Timeout in milliseconds. Defaults to 30 000 ms if None.

Errors

Returns crate::error::Error::Timeout if the context is not closed within the timeout.

Example

// Set up the waiter BEFORE closing
let waiter = context.expect_close(None).await?;
context.close().await?;
waiter.wait().await?;

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-wait-for-event

pub async fn expect_console_message( &self, timeout: Option<f64>, ) -> Result<EventWaiter<ConsoleMessage>>

Waits for a console message from any page in this context.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-event-console

pub async fn expect_event( &self, event: &str, timeout: Option<f64>, ) -> Result<EventWaiter<EventValue>>

Waits for the given event to fire and returns a typed EventValue.

This is the generic version of the specific expect_* methods. It matches the playwright-python / playwright-js context.expect_event(event_name) API.

The waiter must be created before the action that triggers the event.

Supported event names

"page", "close", "console", "request", "response", "weberror", "serviceworker"

Arguments

• event - Event name (case-sensitive, matches Playwright protocol names).
• timeout - Timeout in milliseconds. Defaults to 30 000 ms if None.

Errors

Returns crate::error::Error::InvalidArgument for unknown event names. Returns crate::error::Error::Timeout if the event does not fire within the timeout.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-wait-for-event

pub async fn route_web_socket<F, Fut>( &self, url: &str, handler: F, ) -> Result<()>

where F: Fn(WebSocketRoute) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Intercepts WebSocket connections matching the given URL pattern for all pages in this context.

When a WebSocket connection from any page in this context matches url, the handler is called with a WebSocketRoute object. The handler must call connect_to_server to forward the connection to the real server, or close to terminate it.

Arguments

• url — URL glob pattern (e.g. "ws://**" or "wss://example.com/ws").
• handler — Async closure receiving a WebSocketRoute.

Errors

Returns an error if the RPC call to enable interception fails.

See: https://playwright.dev/docs/api/class-browsercontext#browser-context-route-web-socket

pub fn deserialize_binding_args_pub(raw_args: &Value) -> Vec<Value>

Deserializes binding call arguments from Playwright’s protocol format.

The args field in the BindingCall initializer is a JSON array where each element is in serialize_argument format: {"value": <tagged>, "handles": []}. This helper extracts the inner “value” from each entry and parses it.

This is pub so that Page::on_event("bindingCall") can reuse it without duplicating the deserialization logic.

Trait Implementations

impl Clone for BrowserContext

fn clone(&self) -> BrowserContext

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BrowserContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.