Struct BrowserType

Source

pub struct BrowserType { /* private fields */ }

Expand description

BrowserType represents a browser engine (Chromium, Firefox, or WebKit).

Each Playwright instance provides three BrowserType objects accessible via:

playwright.chromium()
playwright.firefox()
playwright.webkit()

BrowserType provides three main modes:

Launch: Creates a new browser instance
Launch Persistent Context: Creates browser + context with persistent storage
Connect: Connects to an existing remote browser instance

§Example

let playwright = Playwright::launch().await?;
let chromium = playwright.chromium();

// Verify browser type info
assert_eq!(chromium.name(), "chromium");
assert!(!chromium.executable_path().is_empty());

// === Standard Launch ===
// Launch with default options
let browser1 = chromium.launch().await?;
assert_eq!(browser1.name(), "chromium");
assert!(!browser1.version().is_empty());
browser1.close().await?;

// === Remote Connection ===
// Connect to a remote browser (e.g., started with `npx playwright launch-server`)
// let browser3 = chromium.connect("ws://localhost:3000", None).await?;
// browser3.close().await?;

// === CDP Connection (Chromium only) ===
// Connect to a Chrome instance with remote debugging enabled
// let browser4 = chromium.connect_over_cdp("http://localhost:9222", None).await?;
// browser4.close().await?;

// === Persistent Context Launch ===
// Launch with persistent storage (cookies, local storage, etc.)
let context = chromium
    .launch_persistent_context("/tmp/user-data")
    .await?;
let page = context.new_page().await?;
page.goto("https://example.com", None).await?;
context.close().await?; // Closes browser too

// === App Mode (Standalone Window) ===
// Launch as a standalone application window
let app_options = BrowserContextOptions::builder()
    .args(vec!["--app=https://example.com".to_string()])
    .headless(true) // Set to true for CI, but app mode is typically headed
    .build();

let app_context = chromium
    .launch_persistent_context_with_options("/tmp/app-data", app_options)
    .await?;
// Browser opens directly to URL without address bar
app_context.close().await?;

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

Implementations§

Source §

impl BrowserType

Source

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

Creates a new BrowserType object from protocol initialization.

Called by the object factory when server sends create message.

§Arguments

parent - Parent (Connection for root objects, or another ChannelOwner)
type_name - Protocol type name (“BrowserType”)
guid - Unique GUID from server (e.g., “browserType@chromium”)
initializer - Initial state with name and executablePath

Source

pub fn name(&self) -> &str

Returns the browser name (“chromium”, “firefox”, or “webkit”).

Source

pub fn executable_path(&self) -> &str

Returns the path to the browser executable.

Source

pub async fn launch(&self) -> Result<Browser>

Launches a browser instance with default options.

This is equivalent to calling launch_with_options(LaunchOptions::default()).

§Errors

Returns error if:

Browser executable not found
Launch timeout (default 30s)
Browser process fails to start

See: https://playwright.dev/docs/api/class-browsertype#browser-type-launch

Source

pub async fn launch_with_options( &self, options: LaunchOptions, ) -> Result<Browser>

Launches a browser instance with custom options.

§Arguments

options - Launch options (headless, args, etc.)

§Errors

Returns error if:

Browser executable not found
Launch timeout
Invalid options
Browser process fails to start

See: https://playwright.dev/docs/api/class-browsertype#browser-type-launch

Source

pub async fn launch_persistent_context( &self, user_data_dir: impl Into<String>, ) -> Result<BrowserContext>

Launches a browser with persistent storage using default options.

Returns a persistent browser context. Closing this context will automatically close the browser.

This method is useful for:

Preserving authentication state across sessions
Testing with real user profiles
Creating standalone applications with app mode
Simulating real user behavior with cookies and storage

§Arguments

user_data_dir - Path to a user data directory (stores cookies, local storage)

§Errors

Returns error if:

Browser executable not found
Launch timeout (default 30s)
Browser process fails to start
User data directory cannot be created

See: https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context

Source

pub async fn launch_persistent_context_with_options( &self, user_data_dir: impl Into<String>, options: BrowserContextOptions, ) -> Result<BrowserContext>

Launches a browser with persistent storage and custom options.

Returns a persistent browser context with the specified configuration. Closing this context will automatically close the browser.

This method accepts both launch options (headless, args, etc.) and context options (viewport, locale, etc.) in a single BrowserContextOptions struct.

§Arguments

user_data_dir - Path to a user data directory (stores cookies, local storage)
options - Combined launch and context options

§Errors

Returns error if:

Browser executable not found
Launch timeout
Invalid options
Browser process fails to start
User data directory cannot be created

See: https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context

Source

pub async fn connect( &self, ws_endpoint: &str, options: Option<ConnectOptions>, ) -> Result<Browser>

Connects to an existing browser instance.

§Arguments

ws_endpoint - A WebSocket endpoint to connect to.
options - Connection options.

§Errors

Returns error if connection fails or handshake fails.

Source

pub async fn connect_over_cdp( &self, endpoint_url: &str, options: Option<ConnectOverCdpOptions>, ) -> Result<Browser>

Connects to a browser over the Chrome DevTools Protocol.

This method is only supported for Chromium. It connects to an existing Chrome instance that exposes a CDP endpoint (e.g., --remote-debugging-port), or to CDP-compatible services like browserless.

Unlike connect(), which uses Playwright’s proprietary WebSocket protocol, this method connects directly via CDP. The Playwright server manages the CDP connection internally.

§Arguments

endpoint_url - A CDP endpoint URL (e.g., http://localhost:9222 or ws://localhost:9222/devtools/browser/...)
options - Optional connection options.