Struct Browser

Source

pub struct Browser { /* private fields */ }

Expand description

A browser instance connected via CDP.

The Browser struct represents a connection to a Chromium-based browser. It can be obtained by:

Browser::launch() - Spawn and connect to a new browser process
Browser::connect() - Connect to an existing browser via WebSocket URL
Browser::connect_over_cdp() - Connect via HTTP endpoint (auto-discovers WebSocket)

§Key Methods

new_context() - Create a new isolated browser context
contexts() - List all browser contexts (including pre-existing ones)
close() - Close the browser connection

§Ownership

Use is_owned() to check if this browser was launched by us (vs connected to an existing process). Owned browsers are terminated when closed.

Implementations§

Source §

impl Browser

Source

pub fn launch() -> BrowserBuilder

Create a browser builder for launching a new browser.

§Example

use viewpoint_core::Browser;

let browser = Browser::launch()
    .headless(true)
    .launch()
    .await?;

Source

pub async fn connect(ws_url: &str) -> Result<Browser, BrowserError>

Connect to an already-running browser via WebSocket URL.

§Example

use viewpoint_core::Browser;

let browser = Browser::connect("ws://localhost:9222/devtools/browser/...").await?;

§Errors

Returns an error if the connection fails.

Source

pub fn connect_over_cdp( endpoint_url: impl Into<String>, ) -> ConnectOverCdpBuilder

Connect to an already-running browser via HTTP endpoint or WebSocket URL.

This method supports both:

HTTP endpoint URLs (e.g., http://localhost:9222) - auto-discovers WebSocket URL
WebSocket URLs (e.g., ws://localhost:9222/devtools/browser/...) - direct connection

For HTTP endpoints, the method fetches /json/version to discover the WebSocket URL, similar to Playwright’s connectOverCDP.

§Example

use viewpoint_core::Browser;
use std::time::Duration;

// Connect via HTTP endpoint (recommended)
let browser = Browser::connect_over_cdp("http://localhost:9222")
    .connect()
    .await?;

// With custom timeout and headers
let browser = Browser::connect_over_cdp("http://localhost:9222")
    .timeout(Duration::from_secs(10))
    .header("Authorization", "Bearer token")
    .connect()
    .await?;

// Access existing browser contexts and pages
let contexts = browser.contexts().await?;
for context in contexts {
    let pages = context.pages().await?;
    for page in pages {
        println!("Found page: {:?}", page.target_id);
    }
}

Source

pub async fn contexts(&self) -> Result<Vec<BrowserContext>, BrowserError>

Get all browser contexts.

Returns all existing browser contexts, including:

Contexts created via new_context()
The default context (for connected browsers)
Any pre-existing contexts (when connecting to an already-running browser)

§Example

use viewpoint_core::Browser;

let browser = Browser::connect_over_cdp("http://localhost:9222")
    .connect()
    .await?;

let contexts = browser.contexts().await?;
println!("Found {} browser contexts", contexts.len());

// The default context (empty string ID) represents the browser's main profile
for context in &contexts {
    if context.id().is_empty() {
        println!("This is the default context");
    }
}

§Errors

Returns an error if querying contexts fails.

Source

pub async fn new_context(&self) -> Result<BrowserContext, BrowserError>

Create a new isolated browser context.

Browser contexts are isolated environments within the browser, similar to incognito windows. They have their own cookies, cache, and storage.

§Errors

Returns an error if context creation fails.

Source

pub fn new_context_builder(&self) -> NewContextBuilder<'_>

Create a new context options builder.

Use this to create a browser context with custom configuration.

§Example

use viewpoint_core::{Browser, Permission};

let browser = Browser::launch().headless(true).launch().await?;

let context = browser.new_context_builder()
    .geolocation(37.7749, -122.4194)
    .permissions(vec![Permission::Geolocation])
    .offline(false)
    .build()
    .await?;