Struct BrowserType 

pub struct BrowserType { /* private fields */ }

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 two main launching modes:

1. Standard launch: Creates a browser, then contexts and pages separately
2. Persistent context launch: Creates browser + context together with persistent storage

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?;

// Launch with custom options
let options = LaunchOptions::default()
    .headless(true)
    .slow_mo(100.0)
    .args(vec!["--no-sandbox".to_string()]);

let browser2 = chromium.launch_with_options(options).await?;
assert_eq!(browser2.name(), "chromium");
assert!(!browser2.version().is_empty());
browser2.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

impl BrowserType

pub fn new( parent: Arc<dyn ChannelOwner>, 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 Playwright object
• type_name - Protocol type name (“BrowserType”)
• guid - Unique GUID from server (e.g., “browserType@chromium”)
• initializer - Initial state with name and executablePath

pub fn name(&self) -> &str

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

pub fn executable_path(&self) -> &str

Returns the path to the browser executable.

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

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

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

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

Trait Implementations

impl Debug for BrowserType

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

Formats the value using the given formatter.