Struct BrowserBuilder 

pub struct BrowserBuilder { /* private fields */ }

Implementations

impl BrowserBuilder

pub fn new() -> Self

pub fn headful(self) -> Self

Run with visible window.

Examples found in repository

examples/youtube_test.rs (line 8)

async fn main() {
    println!("=== YouTube Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("https://www.youtube.com").await.expect("nav failed");
    page.wait(3000).await;

    let title = page.js("document.title").await.unwrap_or_default();
    let url = page.url().await.unwrap_or_default();
    println!("Title: {title}");
    println!("URL: {url}");

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/smoke_test.rs (line 8)

async fn main() {
    println!("=== Smoke Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    let checks = &[
        ("webdriver", "navigator.webdriver.toString()"),
        ("timezone", "Intl.DateTimeFormat().resolvedOptions().timeZone"),
        ("cores", "navigator.hardwareConcurrency.toString()"),
        ("screen", "screen.width+'x'+screen.height"),
        ("UA", "navigator.userAgent"),
    ];
    for (name, expr) in checks {
        let val = page.js(expr).await.unwrap_or_default();
        println!("{name}: {val}");
    }

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/game_test.rs (line 53)

async fn main() {
    load_dotenv();
    println!("=== Game Test + WS Detection ===\n");

    // 1. Fetch game URL
    println!("Fetching game URL...");
    let client = reqwest::Client::new();
    let resp = client
        .post(api_url())
        .header("Authorization", format!("Bearer {}", api_token()))
        .header("Content-Type", "application/json")
        .header("Accept", "application/json")
        .body(r#"{"user_id": "beezsbee"}"#)
        .send()
        .await
        .expect("API request failed");

    let body: serde_json::Value = resp.json().await.expect("JSON parse failed");
    let game_url = body["url"].as_str().expect("no 'url' in response");
    println!("Game URL: {game_url}\n");

    // 2. Launch browser
    let browser = Browser::builder()
        .headful()
        .profile(42, 12345)
        .build()
        .await
        .expect("browser launch failed");

    // 3. Open blank page first so we can set up listeners before navigation
    let page = browser.new_page("about:blank").await.expect("page failed");

    // Enable network domain for WS events
    page.cdp().execute(EnableParams::default()).await.expect("network enable failed");

    // Set up WS event listeners
    let mut ws_created = page.cdp().event_listener::<EventWebSocketCreated>().await.expect("listener failed");
    let mut ws_closed = page.cdp().event_listener::<EventWebSocketClosed>().await.expect("listener failed");

    // Spawn listener tasks
    tokio::spawn(async move {
        while let Some(ev) = ws_created.next().await {
            println!("[WS CREATED] request_id={:?} url={}", ev.request_id, ev.url);
        }
    });

    tokio::spawn(async move {
        while let Some(ev) = ws_closed.next().await {
            println!("[WS CLOSED]  request_id={:?}", ev.request_id);
        }
    });

    // 4. Navigate to game (human simulation runs automatically)
    println!("Navigating to game...");
    page.navigate(game_url).await.expect("nav failed");

    // 5. Wait and monitor
    println!("Watching for WebSocket connections...\n");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/tls_check.rs (line 26)

async fn main() {
    load_dotenv();
    println!("=== TLS/HTTP2 Fingerprint Check ===\n");

    let browser = Browser::builder()
        .headful()
        .random()
        .build()
        .await
        .expect("browser launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    // 1. Check TLS fingerprint
    println!("--- tls.peet.ws ---");
    page.goto("https://tls.peet.ws/api/all").await.expect("nav failed");
    tokio::time::sleep(std::time::Duration::from_secs(3)).await;

    let body = page.js("document.body.innerText").await.unwrap_or_default();
    if let Ok(v) = serde_json::from_str::<serde_json::Value>(&body) {
        // TLS
        if let Some(tls) = v.get("tls") {
            println!("JA3 hash:    {}", tls.get("ja3_hash").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA3:         {}", tls.get("ja3").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA4:         {}", tls.get("ja4").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("TLS version: {}", tls.get("version").and_then(|v| v.as_str()).unwrap_or("N/A"));
        }

        // HTTP2
        println!();
        if let Some(h2) = v.get("http2") {
            println!("HTTP2 fingerprint:   {}", h2.get("akamai_fingerprint").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("Pseudo-header order: {}", h2.get("sent_pseudo_header_fields_order").unwrap_or(&serde_json::Value::Null));
            if let Some(settings) = h2.get("sent_settings") {
                println!("SETTINGS:            {}", settings);
            }
        }

        // HTTP version used
        println!();
        if let Some(ip) = v.get("ip") {
            println!("Client IP:   {}", ip.as_str().unwrap_or("N/A"));
        }
        if let Some(http_version) = v.get("http_version") {
            println!("HTTP version: {}", http_version.as_str().unwrap_or("N/A"));
        }

        // User-Agent
        println!();
        if let Some(h1) = v.get("http1") {
            if let Some(headers) = h1.get("headers") {
                if let Some(arr) = headers.as_array() {
                    for h in arr {
                        let name = h.get("name").and_then(|n| n.as_str()).unwrap_or("");
                        let val = h.get("value").and_then(|n| n.as_str()).unwrap_or("");
                        if name.to_lowercase() == "user-agent" {
                            println!("User-Agent:  {}", val);
                        }
                    }
                }
            }
        }
    } else {
        println!("Failed to parse response: {}", &body[..body.len().min(500)]);
    }

    // 2. Check known Chrome 134 reference values
    println!("\n--- Expected Chrome 134 stock values ---");
    println!("JA3 hash:    cd49876058a26ccf43e241ccc4e4b5d3  (Chrome 134 Windows)");
    println!("JA4:         t13d1517h2_8daaf6152771_02713d6af8  (Chrome 134 Windows)");
    println!("HTTP2 Akamai: 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p");

    println!("\nBrowser still open. Press Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/batch_test.rs (line 176)

async fn main() {
    load_dotenv();
    let total = PER_ROUND * ROUNDS;
    println!("=== Proxy batch: {}×{} = {} | live {}s | rotate {}s cooldown ===\n",
        PER_ROUND, ROUNDS, total, BROWSER_LIVE_SECS, ROTATE_COOLDOWN_SECS);

    let start = Instant::now();
    let mut ok = 0u32;
    let mut fail = 0u32;

    for round in 0..ROUNDS {
        println!("--- Round {}/{} ---", round + 1, ROUNDS);

        // 1. Rotate IP and get proxy
        let proxy = match rotate_and_get_proxy().await {
            Some(p) => p,
            None => {
                println!("  Skip round — no proxy");
                fail += PER_ROUND as u32;
                continue;
            }
        };

        // 2. Verify proxy works
        if !verify_proxy(&proxy).await {
            println!("  Skip round — proxy dead");
            fail += PER_ROUND as u32;
            continue;
        }

        // 3. Launch 3 browsers in parallel
        let offset = round * PER_ROUND;
        let mut handles = Vec::new();

        for i in 0..PER_ROUND {
            let idx = offset + i;
            let user_id = USERS[idx % USERS.len()].to_string();
            let proxy = proxy.clone();
            let api = api_url();
            let token = api_token();

            handles.push(tokio::spawn(async move {
                let label = format!("[{:02}/{}]", idx + 1, total);
                let t = Instant::now();

                // Get game URL (direct, no proxy)
                let game_url = match reqwest::Client::new()
                    .post(&api)
                    .header("Authorization", format!("Bearer {}", token))
                    .header("Content-Type", "application/json")
                    .body(format!(r#"{{"user_id": "{}"}}"#, user_id))
                    .send().await
                {
                    Ok(resp) => {
                        let body: serde_json::Value = resp.json().await.unwrap_or_default();
                        match body["url"].as_str() {
                            Some(u) if !u.is_empty() => u.to_string(),
                            _ => return format!("{label} FAIL api: {body}"),
                        }
                    }
                    Err(e) => return format!("{label} FAIL api: {e}"),
                };
                let api_ms = t.elapsed().as_millis();

                // Launch browser with proxy
                let browser = match Browser::builder()
                    .headful()
                    .random()
                    .proxy(&proxy)
                    .build().await
                {
                    Ok(b) => b,
                    Err(e) => return format!("{label} FAIL launch: {e}"),
                };
                let launch_ms = t.elapsed().as_millis() - api_ms;

                // Navigate (human simulation auto-starts with aggressive scroll)
                let page = match browser.new_page("about:blank").await {
                    Ok(p) => p,
                    Err(e) => return format!("{label} FAIL page: {e}"),
                };

                // Aggressive scrolling in background
                let scroll_page = page.cdp().clone();
                let scroll_handle = tokio::spawn(async move {
                    use chromiumoxide::cdp::browser_protocol::input::{
                        DispatchMouseEventParams, DispatchMouseEventType,
                    };
                    let mut y = 300.0f64;
                    loop {
                        // Scroll down aggressively
                        let mut ev = DispatchMouseEventParams::new(
                            DispatchMouseEventType::MouseWheel, 500.0, y,
                        );
                        ev.delta_x = Some(0.0);
                        ev.delta_y = Some(300.0);
                        let _ = scroll_page.execute(ev).await;
                        y = ((y + 50.0) % 800.0) + 100.0;
                        tokio::time::sleep(std::time::Duration::from_millis(800)).await;
                    }
                });

                let t_nav = Instant::now();
                if let Err(e) = page.goto(&game_url).await {
                    scroll_handle.abort();
                    return format!("{label} FAIL nav: {e}");
                }
                let nav_ms = t_nav.elapsed().as_millis();

                // Wait for cookies
                tokio::time::sleep(std::time::Duration::from_secs(5)).await;

                let cookies = page.cdp().get_cookies().await.unwrap_or_default();
                let has_evo = cookies.iter().any(|c| c.name == "EVOSESSIONID");
                let evo = cookies.iter().find(|c| c.name == "EVOSESSIONID")
                    .map(|c| c.value.clone())
                    .unwrap_or_else(|| "N/A".into());
                let cookie_names: Vec<String> = cookies.iter().map(|c| c.name.clone()).collect();

                // Stay alive for remaining time (human sim + aggressive scroll running)
                let elapsed = t.elapsed().as_secs();
                if elapsed < BROWSER_LIVE_SECS {
                    tokio::time::sleep(std::time::Duration::from_secs(BROWSER_LIVE_SECS - elapsed)).await;
                }

                // Close browser
                scroll_handle.abort();
                let _ = browser.close().await;
                let total_ms = t.elapsed().as_millis();

                let status = if has_evo { "OK" } else { "MISS" };
                format!("{label} {status} | {user_id:<18} | total:{total_ms}ms api:{api_ms}ms launch:{launch_ms}ms nav:{nav_ms}ms | cookies:{} | EVO:{evo}\n       {:?}",
                    cookies.len(), cookie_names)
            }));
        }

        for h in handles {
            match h.await {
                Ok(msg) => {
                    if msg.contains("] OK ") { ok += 1; } else { fail += 1; }
                    println!("{msg}");
                }
                Err(e) => { println!("  task panic: {e}"); fail += 1; }
            }
        }

        println!();
    }

    let elapsed = start.elapsed().as_secs_f64();
    println!("=== OK:{ok} FAIL:{fail} | {elapsed:.0}s total | {:.1}s/profile ===",
        elapsed / total as f64);
}

pub fn headless(self) -> Self

Run in headless mode (default).

pub fn chrome_path(self, path: impl Into<String>) -> Self

Path to chrome.exe. Falls back to CLAWSER_CHROME_PATH env.

pub fn profile(self, index: usize, seed: u64) -> Self

Use hardware profile index (0..99) with deterministic seed.

Examples found in repository

examples/youtube_test.rs (line 9)

async fn main() {
    println!("=== YouTube Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("https://www.youtube.com").await.expect("nav failed");
    page.wait(3000).await;

    let title = page.js("document.title").await.unwrap_or_default();
    let url = page.url().await.unwrap_or_default();
    println!("Title: {title}");
    println!("URL: {url}");

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/smoke_test.rs (line 9)

async fn main() {
    println!("=== Smoke Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    let checks = &[
        ("webdriver", "navigator.webdriver.toString()"),
        ("timezone", "Intl.DateTimeFormat().resolvedOptions().timeZone"),
        ("cores", "navigator.hardwareConcurrency.toString()"),
        ("screen", "screen.width+'x'+screen.height"),
        ("UA", "navigator.userAgent"),
    ];
    for (name, expr) in checks {
        let val = page.js(expr).await.unwrap_or_default();
        println!("{name}: {val}");
    }

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/game_test.rs (line 54)

async fn main() {
    load_dotenv();
    println!("=== Game Test + WS Detection ===\n");

    // 1. Fetch game URL
    println!("Fetching game URL...");
    let client = reqwest::Client::new();
    let resp = client
        .post(api_url())
        .header("Authorization", format!("Bearer {}", api_token()))
        .header("Content-Type", "application/json")
        .header("Accept", "application/json")
        .body(r#"{"user_id": "beezsbee"}"#)
        .send()
        .await
        .expect("API request failed");

    let body: serde_json::Value = resp.json().await.expect("JSON parse failed");
    let game_url = body["url"].as_str().expect("no 'url' in response");
    println!("Game URL: {game_url}\n");

    // 2. Launch browser
    let browser = Browser::builder()
        .headful()
        .profile(42, 12345)
        .build()
        .await
        .expect("browser launch failed");

    // 3. Open blank page first so we can set up listeners before navigation
    let page = browser.new_page("about:blank").await.expect("page failed");

    // Enable network domain for WS events
    page.cdp().execute(EnableParams::default()).await.expect("network enable failed");

    // Set up WS event listeners
    let mut ws_created = page.cdp().event_listener::<EventWebSocketCreated>().await.expect("listener failed");
    let mut ws_closed = page.cdp().event_listener::<EventWebSocketClosed>().await.expect("listener failed");

    // Spawn listener tasks
    tokio::spawn(async move {
        while let Some(ev) = ws_created.next().await {
            println!("[WS CREATED] request_id={:?} url={}", ev.request_id, ev.url);
        }
    });

    tokio::spawn(async move {
        while let Some(ev) = ws_closed.next().await {
            println!("[WS CLOSED]  request_id={:?}", ev.request_id);
        }
    });

    // 4. Navigate to game (human simulation runs automatically)
    println!("Navigating to game...");
    page.navigate(game_url).await.expect("nav failed");

    // 5. Wait and monitor
    println!("Watching for WebSocket connections...\n");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

pub fn random(self) -> Self

Use a random hardware profile.

Examples found in repository

examples/tls_check.rs (line 27)

async fn main() {
    load_dotenv();
    println!("=== TLS/HTTP2 Fingerprint Check ===\n");

    let browser = Browser::builder()
        .headful()
        .random()
        .build()
        .await
        .expect("browser launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    // 1. Check TLS fingerprint
    println!("--- tls.peet.ws ---");
    page.goto("https://tls.peet.ws/api/all").await.expect("nav failed");
    tokio::time::sleep(std::time::Duration::from_secs(3)).await;

    let body = page.js("document.body.innerText").await.unwrap_or_default();
    if let Ok(v) = serde_json::from_str::<serde_json::Value>(&body) {
        // TLS
        if let Some(tls) = v.get("tls") {
            println!("JA3 hash:    {}", tls.get("ja3_hash").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA3:         {}", tls.get("ja3").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA4:         {}", tls.get("ja4").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("TLS version: {}", tls.get("version").and_then(|v| v.as_str()).unwrap_or("N/A"));
        }

        // HTTP2
        println!();
        if let Some(h2) = v.get("http2") {
            println!("HTTP2 fingerprint:   {}", h2.get("akamai_fingerprint").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("Pseudo-header order: {}", h2.get("sent_pseudo_header_fields_order").unwrap_or(&serde_json::Value::Null));
            if let Some(settings) = h2.get("sent_settings") {
                println!("SETTINGS:            {}", settings);
            }
        }

        // HTTP version used
        println!();
        if let Some(ip) = v.get("ip") {
            println!("Client IP:   {}", ip.as_str().unwrap_or("N/A"));
        }
        if let Some(http_version) = v.get("http_version") {
            println!("HTTP version: {}", http_version.as_str().unwrap_or("N/A"));
        }

        // User-Agent
        println!();
        if let Some(h1) = v.get("http1") {
            if let Some(headers) = h1.get("headers") {
                if let Some(arr) = headers.as_array() {
                    for h in arr {
                        let name = h.get("name").and_then(|n| n.as_str()).unwrap_or("");
                        let val = h.get("value").and_then(|n| n.as_str()).unwrap_or("");
                        if name.to_lowercase() == "user-agent" {
                            println!("User-Agent:  {}", val);
                        }
                    }
                }
            }
        }
    } else {
        println!("Failed to parse response: {}", &body[..body.len().min(500)]);
    }

    // 2. Check known Chrome 134 reference values
    println!("\n--- Expected Chrome 134 stock values ---");
    println!("JA3 hash:    cd49876058a26ccf43e241ccc4e4b5d3  (Chrome 134 Windows)");
    println!("JA4:         t13d1517h2_8daaf6152771_02713d6af8  (Chrome 134 Windows)");
    println!("HTTP2 Akamai: 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p");

    println!("\nBrowser still open. Press Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/batch_test.rs (line 177)

async fn main() {
    load_dotenv();
    let total = PER_ROUND * ROUNDS;
    println!("=== Proxy batch: {}×{} = {} | live {}s | rotate {}s cooldown ===\n",
        PER_ROUND, ROUNDS, total, BROWSER_LIVE_SECS, ROTATE_COOLDOWN_SECS);

    let start = Instant::now();
    let mut ok = 0u32;
    let mut fail = 0u32;

    for round in 0..ROUNDS {
        println!("--- Round {}/{} ---", round + 1, ROUNDS);

        // 1. Rotate IP and get proxy
        let proxy = match rotate_and_get_proxy().await {
            Some(p) => p,
            None => {
                println!("  Skip round — no proxy");
                fail += PER_ROUND as u32;
                continue;
            }
        };

        // 2. Verify proxy works
        if !verify_proxy(&proxy).await {
            println!("  Skip round — proxy dead");
            fail += PER_ROUND as u32;
            continue;
        }

        // 3. Launch 3 browsers in parallel
        let offset = round * PER_ROUND;
        let mut handles = Vec::new();

        for i in 0..PER_ROUND {
            let idx = offset + i;
            let user_id = USERS[idx % USERS.len()].to_string();
            let proxy = proxy.clone();
            let api = api_url();
            let token = api_token();

            handles.push(tokio::spawn(async move {
                let label = format!("[{:02}/{}]", idx + 1, total);
                let t = Instant::now();

                // Get game URL (direct, no proxy)
                let game_url = match reqwest::Client::new()
                    .post(&api)
                    .header("Authorization", format!("Bearer {}", token))
                    .header("Content-Type", "application/json")
                    .body(format!(r#"{{"user_id": "{}"}}"#, user_id))
                    .send().await
                {
                    Ok(resp) => {
                        let body: serde_json::Value = resp.json().await.unwrap_or_default();
                        match body["url"].as_str() {
                            Some(u) if !u.is_empty() => u.to_string(),
                            _ => return format!("{label} FAIL api: {body}"),
                        }
                    }
                    Err(e) => return format!("{label} FAIL api: {e}"),
                };
                let api_ms = t.elapsed().as_millis();

                // Launch browser with proxy
                let browser = match Browser::builder()
                    .headful()
                    .random()
                    .proxy(&proxy)
                    .build().await
                {
                    Ok(b) => b,
                    Err(e) => return format!("{label} FAIL launch: {e}"),
                };
                let launch_ms = t.elapsed().as_millis() - api_ms;

                // Navigate (human simulation auto-starts with aggressive scroll)
                let page = match browser.new_page("about:blank").await {
                    Ok(p) => p,
                    Err(e) => return format!("{label} FAIL page: {e}"),
                };

                // Aggressive scrolling in background
                let scroll_page = page.cdp().clone();
                let scroll_handle = tokio::spawn(async move {
                    use chromiumoxide::cdp::browser_protocol::input::{
                        DispatchMouseEventParams, DispatchMouseEventType,
                    };
                    let mut y = 300.0f64;
                    loop {
                        // Scroll down aggressively
                        let mut ev = DispatchMouseEventParams::new(
                            DispatchMouseEventType::MouseWheel, 500.0, y,
                        );
                        ev.delta_x = Some(0.0);
                        ev.delta_y = Some(300.0);
                        let _ = scroll_page.execute(ev).await;
                        y = ((y + 50.0) % 800.0) + 100.0;
                        tokio::time::sleep(std::time::Duration::from_millis(800)).await;
                    }
                });

                let t_nav = Instant::now();
                if let Err(e) = page.goto(&game_url).await {
                    scroll_handle.abort();
                    return format!("{label} FAIL nav: {e}");
                }
                let nav_ms = t_nav.elapsed().as_millis();

                // Wait for cookies
                tokio::time::sleep(std::time::Duration::from_secs(5)).await;

                let cookies = page.cdp().get_cookies().await.unwrap_or_default();
                let has_evo = cookies.iter().any(|c| c.name == "EVOSESSIONID");
                let evo = cookies.iter().find(|c| c.name == "EVOSESSIONID")
                    .map(|c| c.value.clone())
                    .unwrap_or_else(|| "N/A".into());
                let cookie_names: Vec<String> = cookies.iter().map(|c| c.name.clone()).collect();

                // Stay alive for remaining time (human sim + aggressive scroll running)
                let elapsed = t.elapsed().as_secs();
                if elapsed < BROWSER_LIVE_SECS {
                    tokio::time::sleep(std::time::Duration::from_secs(BROWSER_LIVE_SECS - elapsed)).await;
                }

                // Close browser
                scroll_handle.abort();
                let _ = browser.close().await;
                let total_ms = t.elapsed().as_millis();

                let status = if has_evo { "OK" } else { "MISS" };
                format!("{label} {status} | {user_id:<18} | total:{total_ms}ms api:{api_ms}ms launch:{launch_ms}ms nav:{nav_ms}ms | cookies:{} | EVO:{evo}\n       {:?}",
                    cookies.len(), cookie_names)
            }));
        }

        for h in handles {
            match h.await {
                Ok(msg) => {
                    if msg.contains("] OK ") { ok += 1; } else { fail += 1; }
                    println!("{msg}");
                }
                Err(e) => { println!("  task panic: {e}"); fail += 1; }
            }
        }

        println!();
    }

    let elapsed = start.elapsed().as_secs_f64();
    println!("=== OK:{ok} FAIL:{fail} | {elapsed:.0}s total | {:.1}s/profile ===",
        elapsed / total as f64);
}

pub fn config(self, path: impl Into<String>) -> Self

Use a custom clawser config JSON file path.

pub fn user_data_dir(self, path: impl Into<String>) -> Self

Persistent user data dir for cookies/storage.

pub fn window_size(self, w: u32, h: u32) -> Self

Window size (default 1920x1080).

pub fn proxy(self, proxy: impl Into<String>) -> Self

Set SOCKS5 proxy. Format: "socks5://user:pass@host:port". Also accepts "socks5://host:port" (no auth).

Examples found in repository

examples/batch_test.rs (line 178)

async fn main() {
    load_dotenv();
    let total = PER_ROUND * ROUNDS;
    println!("=== Proxy batch: {}×{} = {} | live {}s | rotate {}s cooldown ===\n",
        PER_ROUND, ROUNDS, total, BROWSER_LIVE_SECS, ROTATE_COOLDOWN_SECS);

    let start = Instant::now();
    let mut ok = 0u32;
    let mut fail = 0u32;

    for round in 0..ROUNDS {
        println!("--- Round {}/{} ---", round + 1, ROUNDS);

        // 1. Rotate IP and get proxy
        let proxy = match rotate_and_get_proxy().await {
            Some(p) => p,
            None => {
                println!("  Skip round — no proxy");
                fail += PER_ROUND as u32;
                continue;
            }
        };

        // 2. Verify proxy works
        if !verify_proxy(&proxy).await {
            println!("  Skip round — proxy dead");
            fail += PER_ROUND as u32;
            continue;
        }

        // 3. Launch 3 browsers in parallel
        let offset = round * PER_ROUND;
        let mut handles = Vec::new();

        for i in 0..PER_ROUND {
            let idx = offset + i;
            let user_id = USERS[idx % USERS.len()].to_string();
            let proxy = proxy.clone();
            let api = api_url();
            let token = api_token();

            handles.push(tokio::spawn(async move {
                let label = format!("[{:02}/{}]", idx + 1, total);
                let t = Instant::now();

                // Get game URL (direct, no proxy)
                let game_url = match reqwest::Client::new()
                    .post(&api)
                    .header("Authorization", format!("Bearer {}", token))
                    .header("Content-Type", "application/json")
                    .body(format!(r#"{{"user_id": "{}"}}"#, user_id))
                    .send().await
                {
                    Ok(resp) => {
                        let body: serde_json::Value = resp.json().await.unwrap_or_default();
                        match body["url"].as_str() {
                            Some(u) if !u.is_empty() => u.to_string(),
                            _ => return format!("{label} FAIL api: {body}"),
                        }
                    }
                    Err(e) => return format!("{label} FAIL api: {e}"),
                };
                let api_ms = t.elapsed().as_millis();

                // Launch browser with proxy
                let browser = match Browser::builder()
                    .headful()
                    .random()
                    .proxy(&proxy)
                    .build().await
                {
                    Ok(b) => b,
                    Err(e) => return format!("{label} FAIL launch: {e}"),
                };
                let launch_ms = t.elapsed().as_millis() - api_ms;

                // Navigate (human simulation auto-starts with aggressive scroll)
                let page = match browser.new_page("about:blank").await {
                    Ok(p) => p,
                    Err(e) => return format!("{label} FAIL page: {e}"),
                };

                // Aggressive scrolling in background
                let scroll_page = page.cdp().clone();
                let scroll_handle = tokio::spawn(async move {
                    use chromiumoxide::cdp::browser_protocol::input::{
                        DispatchMouseEventParams, DispatchMouseEventType,
                    };
                    let mut y = 300.0f64;
                    loop {
                        // Scroll down aggressively
                        let mut ev = DispatchMouseEventParams::new(
                            DispatchMouseEventType::MouseWheel, 500.0, y,
                        );
                        ev.delta_x = Some(0.0);
                        ev.delta_y = Some(300.0);
                        let _ = scroll_page.execute(ev).await;
                        y = ((y + 50.0) % 800.0) + 100.0;
                        tokio::time::sleep(std::time::Duration::from_millis(800)).await;
                    }
                });

                let t_nav = Instant::now();
                if let Err(e) = page.goto(&game_url).await {
                    scroll_handle.abort();
                    return format!("{label} FAIL nav: {e}");
                }
                let nav_ms = t_nav.elapsed().as_millis();

                // Wait for cookies
                tokio::time::sleep(std::time::Duration::from_secs(5)).await;

                let cookies = page.cdp().get_cookies().await.unwrap_or_default();
                let has_evo = cookies.iter().any(|c| c.name == "EVOSESSIONID");
                let evo = cookies.iter().find(|c| c.name == "EVOSESSIONID")
                    .map(|c| c.value.clone())
                    .unwrap_or_else(|| "N/A".into());
                let cookie_names: Vec<String> = cookies.iter().map(|c| c.name.clone()).collect();

                // Stay alive for remaining time (human sim + aggressive scroll running)
                let elapsed = t.elapsed().as_secs();
                if elapsed < BROWSER_LIVE_SECS {
                    tokio::time::sleep(std::time::Duration::from_secs(BROWSER_LIVE_SECS - elapsed)).await;
                }

                // Close browser
                scroll_handle.abort();
                let _ = browser.close().await;
                let total_ms = t.elapsed().as_millis();

                let status = if has_evo { "OK" } else { "MISS" };
                format!("{label} {status} | {user_id:<18} | total:{total_ms}ms api:{api_ms}ms launch:{launch_ms}ms nav:{nav_ms}ms | cookies:{} | EVO:{evo}\n       {:?}",
                    cookies.len(), cookie_names)
            }));
        }

        for h in handles {
            match h.await {
                Ok(msg) => {
                    if msg.contains("] OK ") { ok += 1; } else { fail += 1; }
                    println!("{msg}");
                }
                Err(e) => { println!("  task panic: {e}"); fail += 1; }
            }
        }

        println!();
    }

    let elapsed = start.elapsed().as_secs_f64();
    println!("=== OK:{ok} FAIL:{fail} | {elapsed:.0}s total | {:.1}s/profile ===",
        elapsed / total as f64);
}

pub fn proxy_socks5(self, host: &str, port: u16, user: &str, pass: &str) -> Self

Set SOCKS5 proxy from host, port, user, pass components.

pub fn arg(self, arg: impl Into<String>) -> Self

Add a Chrome launch argument (e.g. "disable-gpu").

pub async fn build(self) -> Result<Browser>

Launch the browser.

Examples found in repository

examples/youtube_test.rs (line 10)

async fn main() {
    println!("=== YouTube Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("https://www.youtube.com").await.expect("nav failed");
    page.wait(3000).await;

    let title = page.js("document.title").await.unwrap_or_default();
    let url = page.url().await.unwrap_or_default();
    println!("Title: {title}");
    println!("URL: {url}");

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/smoke_test.rs (line 10)

async fn main() {
    println!("=== Smoke Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    let checks = &[
        ("webdriver", "navigator.webdriver.toString()"),
        ("timezone", "Intl.DateTimeFormat().resolvedOptions().timeZone"),
        ("cores", "navigator.hardwareConcurrency.toString()"),
        ("screen", "screen.width+'x'+screen.height"),
        ("UA", "navigator.userAgent"),
    ];
    for (name, expr) in checks {
        let val = page.js(expr).await.unwrap_or_default();
        println!("{name}: {val}");
    }

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/game_test.rs (line 55)

async fn main() {
    load_dotenv();
    println!("=== Game Test + WS Detection ===\n");

    // 1. Fetch game URL
    println!("Fetching game URL...");
    let client = reqwest::Client::new();
    let resp = client
        .post(api_url())
        .header("Authorization", format!("Bearer {}", api_token()))
        .header("Content-Type", "application/json")
        .header("Accept", "application/json")
        .body(r#"{"user_id": "beezsbee"}"#)
        .send()
        .await
        .expect("API request failed");

    let body: serde_json::Value = resp.json().await.expect("JSON parse failed");
    let game_url = body["url"].as_str().expect("no 'url' in response");
    println!("Game URL: {game_url}\n");

    // 2. Launch browser
    let browser = Browser::builder()
        .headful()
        .profile(42, 12345)
        .build()
        .await
        .expect("browser launch failed");

    // 3. Open blank page first so we can set up listeners before navigation
    let page = browser.new_page("about:blank").await.expect("page failed");

    // Enable network domain for WS events
    page.cdp().execute(EnableParams::default()).await.expect("network enable failed");

    // Set up WS event listeners
    let mut ws_created = page.cdp().event_listener::<EventWebSocketCreated>().await.expect("listener failed");
    let mut ws_closed = page.cdp().event_listener::<EventWebSocketClosed>().await.expect("listener failed");

    // Spawn listener tasks
    tokio::spawn(async move {
        while let Some(ev) = ws_created.next().await {
            println!("[WS CREATED] request_id={:?} url={}", ev.request_id, ev.url);
        }
    });

    tokio::spawn(async move {
        while let Some(ev) = ws_closed.next().await {
            println!("[WS CLOSED]  request_id={:?}", ev.request_id);
        }
    });

    // 4. Navigate to game (human simulation runs automatically)
    println!("Navigating to game...");
    page.navigate(game_url).await.expect("nav failed");

    // 5. Wait and monitor
    println!("Watching for WebSocket connections...\n");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/tls_check.rs (line 28)

async fn main() {
    load_dotenv();
    println!("=== TLS/HTTP2 Fingerprint Check ===\n");

    let browser = Browser::builder()
        .headful()
        .random()
        .build()
        .await
        .expect("browser launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    // 1. Check TLS fingerprint
    println!("--- tls.peet.ws ---");
    page.goto("https://tls.peet.ws/api/all").await.expect("nav failed");
    tokio::time::sleep(std::time::Duration::from_secs(3)).await;

    let body = page.js("document.body.innerText").await.unwrap_or_default();
    if let Ok(v) = serde_json::from_str::<serde_json::Value>(&body) {
        // TLS
        if let Some(tls) = v.get("tls") {
            println!("JA3 hash:    {}", tls.get("ja3_hash").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA3:         {}", tls.get("ja3").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA4:         {}", tls.get("ja4").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("TLS version: {}", tls.get("version").and_then(|v| v.as_str()).unwrap_or("N/A"));
        }

        // HTTP2
        println!();
        if let Some(h2) = v.get("http2") {
            println!("HTTP2 fingerprint:   {}", h2.get("akamai_fingerprint").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("Pseudo-header order: {}", h2.get("sent_pseudo_header_fields_order").unwrap_or(&serde_json::Value::Null));
            if let Some(settings) = h2.get("sent_settings") {
                println!("SETTINGS:            {}", settings);
            }
        }

        // HTTP version used
        println!();
        if let Some(ip) = v.get("ip") {
            println!("Client IP:   {}", ip.as_str().unwrap_or("N/A"));
        }
        if let Some(http_version) = v.get("http_version") {
            println!("HTTP version: {}", http_version.as_str().unwrap_or("N/A"));
        }

        // User-Agent
        println!();
        if let Some(h1) = v.get("http1") {
            if let Some(headers) = h1.get("headers") {
                if let Some(arr) = headers.as_array() {
                    for h in arr {
                        let name = h.get("name").and_then(|n| n.as_str()).unwrap_or("");
                        let val = h.get("value").and_then(|n| n.as_str()).unwrap_or("");
                        if name.to_lowercase() == "user-agent" {
                            println!("User-Agent:  {}", val);
                        }
                    }
                }
            }
        }
    } else {
        println!("Failed to parse response: {}", &body[..body.len().min(500)]);
    }

    // 2. Check known Chrome 134 reference values
    println!("\n--- Expected Chrome 134 stock values ---");
    println!("JA3 hash:    cd49876058a26ccf43e241ccc4e4b5d3  (Chrome 134 Windows)");
    println!("JA4:         t13d1517h2_8daaf6152771_02713d6af8  (Chrome 134 Windows)");
    println!("HTTP2 Akamai: 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p");

    println!("\nBrowser still open. Press Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/batch_test.rs (line 179)

async fn main() {
    load_dotenv();
    let total = PER_ROUND * ROUNDS;
    println!("=== Proxy batch: {}×{} = {} | live {}s | rotate {}s cooldown ===\n",
        PER_ROUND, ROUNDS, total, BROWSER_LIVE_SECS, ROTATE_COOLDOWN_SECS);

    let start = Instant::now();
    let mut ok = 0u32;
    let mut fail = 0u32;

    for round in 0..ROUNDS {
        println!("--- Round {}/{} ---", round + 1, ROUNDS);

        // 1. Rotate IP and get proxy
        let proxy = match rotate_and_get_proxy().await {
            Some(p) => p,
            None => {
                println!("  Skip round — no proxy");
                fail += PER_ROUND as u32;
                continue;
            }
        };

        // 2. Verify proxy works
        if !verify_proxy(&proxy).await {
            println!("  Skip round — proxy dead");
            fail += PER_ROUND as u32;
            continue;
        }

        // 3. Launch 3 browsers in parallel
        let offset = round * PER_ROUND;
        let mut handles = Vec::new();

        for i in 0..PER_ROUND {
            let idx = offset + i;
            let user_id = USERS[idx % USERS.len()].to_string();
            let proxy = proxy.clone();
            let api = api_url();
            let token = api_token();

            handles.push(tokio::spawn(async move {
                let label = format!("[{:02}/{}]", idx + 1, total);
                let t = Instant::now();

                // Get game URL (direct, no proxy)
                let game_url = match reqwest::Client::new()
                    .post(&api)
                    .header("Authorization", format!("Bearer {}", token))
                    .header("Content-Type", "application/json")
                    .body(format!(r#"{{"user_id": "{}"}}"#, user_id))
                    .send().await
                {
                    Ok(resp) => {
                        let body: serde_json::Value = resp.json().await.unwrap_or_default();
                        match body["url"].as_str() {
                            Some(u) if !u.is_empty() => u.to_string(),
                            _ => return format!("{label} FAIL api: {body}"),
                        }
                    }
                    Err(e) => return format!("{label} FAIL api: {e}"),
                };
                let api_ms = t.elapsed().as_millis();

                // Launch browser with proxy
                let browser = match Browser::builder()
                    .headful()
                    .random()
                    .proxy(&proxy)
                    .build().await
                {
                    Ok(b) => b,
                    Err(e) => return format!("{label} FAIL launch: {e}"),
                };
                let launch_ms = t.elapsed().as_millis() - api_ms;

                // Navigate (human simulation auto-starts with aggressive scroll)
                let page = match browser.new_page("about:blank").await {
                    Ok(p) => p,
                    Err(e) => return format!("{label} FAIL page: {e}"),
                };

                // Aggressive scrolling in background
                let scroll_page = page.cdp().clone();
                let scroll_handle = tokio::spawn(async move {
                    use chromiumoxide::cdp::browser_protocol::input::{
                        DispatchMouseEventParams, DispatchMouseEventType,
                    };
                    let mut y = 300.0f64;
                    loop {
                        // Scroll down aggressively
                        let mut ev = DispatchMouseEventParams::new(
                            DispatchMouseEventType::MouseWheel, 500.0, y,
                        );
                        ev.delta_x = Some(0.0);
                        ev.delta_y = Some(300.0);
                        let _ = scroll_page.execute(ev).await;
                        y = ((y + 50.0) % 800.0) + 100.0;
                        tokio::time::sleep(std::time::Duration::from_millis(800)).await;
                    }
                });

                let t_nav = Instant::now();
                if let Err(e) = page.goto(&game_url).await {
                    scroll_handle.abort();
                    return format!("{label} FAIL nav: {e}");
                }
                let nav_ms = t_nav.elapsed().as_millis();

                // Wait for cookies
                tokio::time::sleep(std::time::Duration::from_secs(5)).await;

                let cookies = page.cdp().get_cookies().await.unwrap_or_default();
                let has_evo = cookies.iter().any(|c| c.name == "EVOSESSIONID");
                let evo = cookies.iter().find(|c| c.name == "EVOSESSIONID")
                    .map(|c| c.value.clone())
                    .unwrap_or_else(|| "N/A".into());
                let cookie_names: Vec<String> = cookies.iter().map(|c| c.name.clone()).collect();

                // Stay alive for remaining time (human sim + aggressive scroll running)
                let elapsed = t.elapsed().as_secs();
                if elapsed < BROWSER_LIVE_SECS {
                    tokio::time::sleep(std::time::Duration::from_secs(BROWSER_LIVE_SECS - elapsed)).await;
                }

                // Close browser
                scroll_handle.abort();
                let _ = browser.close().await;
                let total_ms = t.elapsed().as_millis();

                let status = if has_evo { "OK" } else { "MISS" };
                format!("{label} {status} | {user_id:<18} | total:{total_ms}ms api:{api_ms}ms launch:{launch_ms}ms nav:{nav_ms}ms | cookies:{} | EVO:{evo}\n       {:?}",
                    cookies.len(), cookie_names)
            }));
        }

        for h in handles {
            match h.await {
                Ok(msg) => {
                    if msg.contains("] OK ") { ok += 1; } else { fail += 1; }
                    println!("{msg}");
                }
                Err(e) => { println!("  task panic: {e}"); fail += 1; }
            }
        }

        println!();
    }

    let elapsed = start.elapsed().as_secs_f64();
    println!("=== OK:{ok} FAIL:{fail} | {elapsed:.0}s total | {:.1}s/profile ===",
        elapsed / total as f64);
}

Trait Implementations

impl Default for BrowserBuilder

fn default() -> Self

Returns the “default value” for a type.