BBRESession Overview

What is BBRESession?

The BBRESession class represents a stateful browser session managed by the BBRE engine. Unlike BBREClient, which treats every request as an independent operation, BBRESession creates a persistent server-side session that maintains a real browser instance with its own cookies, fingerprint profile, and browsing history. Every request you send through a BBRESession instance goes through the same browser context on the server, which means the target website sees a consistent visitor identity across all your requests.

At its core, BBRESession is a BBREClient with session state bolted on. It extends BBREClient through standard JavaScript class inheritance, so every method available on BBREClient is also available on BBRESession. On top of that, it adds session lifecycle methods (start(), close(), status()), session-scoped request handling, cookie persistence, profile tracking, browser speed configuration, and a built-in BrowserAPI instance for direct browser automation.

The BBRE system allows a maximum of 10 active sessions per account at any given time. Each session consumes server resources (a dedicated browser instance), so it is important to close sessions when you are done with them. Sessions also have a configurable timeout (between 0.5 and 5 minutes) after which they expire automatically if no activity is detected.

Class Hierarchy

The SDK is built around three classes that work together. Understanding their relationship helps you choose the right tool for each task.

BBREClient (base class)
  |
  +-- BBRESession (extends BBREClient)
        |
        +-- this.browser (BrowserAPI instance)

BBREClient is the foundation. It handles API authentication, request creation, response polling, HTTP convenience methods, account queries, session management via the API, and default configuration. Every interaction with the BBRE API goes through methods defined on BBREClient.

BBRESession extends BBREClient and adds session awareness. When you call start(), it uses the inherited createSession() method to open a session on the server, then stores the session ID, expiration time, and profile locally. All subsequent requests through the session instance automatically include the session ID and merge cookies. When you call close(), it uses the inherited closeSession() method to terminate the server-side session and resets the local state.

BrowserAPI is a helper class that provides a clean interface for browser automation actions. Every BBRESession instance creates a BrowserAPI instance at this.browser during construction. The BrowserAPI methods (like navigate(), click(), fill()) internally call the session's _browserAction() method, which sends browser action requests to the BBRE API using the session ID.

Inheritance from BBREClient

Because BBRESession extends BBREClient, every method and property defined on BBREClient is available on your session instance. This means you can use a BBRESession instance for both session-based workflows and standalone operations without creating a separate BBREClient. The following table lists all inherited methods and what they do when called on a BBRESession instance.

Inherited Methods from BBREClient

Important Note About Inherited HTTP Methods

The inherited HTTP convenience methods (get(), post(), etc.) call the parent BBREClient.request() method, not the overridden BBRESession.request() method. This means they send standalone requests through the BBRE engine without using the session context. If you want to send requests within the session (preserving cookies and using the session's browser instance), use the session's own request() method directly:

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({ apiKey: "YOUR_API_KEY", mode: "adaptive" });
await session.start();

const sessionResponse = await session.request({
  url: "https://example.com/dashboard",
  method: "GET"
});

const standaloneResponse = await session.get("https://example.com/public-page");

await session.close();

Constructor Configuration

The BBRESession constructor accepts a configuration object that includes all BBREClient parameters plus three session-specific parameters: browserSpeed, force, and sessionTime. The constructor calls super(config) to initialize the BBREClient base class with the shared parameters, then sets up the session-specific state including an empty cookie store, null session ID, null profile, and a new BrowserAPI instance.

Constructor Signature

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession(config);

Inherited Parameters (from BBREClient)

These parameters are passed to the BBREClient constructor through super(config) and control the base client behavior.

Session-Specific Parameters

These parameters are unique to BBRESession and control session behavior, browser speed, and error handling.

Full Constructor Example

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sensibility: "high",
  timeout: 180,
  pollingInterval: 3000,
  fingerprint: {
    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    platform: "Win32",
    screenWidth: 1920,
    screenHeight: 1080,
    timezone: "America/New_York",
    locale: "en-US"
  },
  proxy: "http://user:[email protected]:8080",
  browserSpeed: "human",
  force: true,
  sessionTime: 4
});

Minimal Constructor Example

For most use cases, you only need to provide the API key and the mode. The following example creates a session with adaptive mode (required for browser actions) and all other parameters at their default values.

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive"
});

What Happens During Construction

When you create a new BBRESession instance, the constructor performs the following steps in order:

1. Calls super(config) to initialize the BBREClient base class with apiKey, mode, sensibility, timeout, pollingInterval, fingerprint, and proxy.
2. Initializes this.sessionCookies as an empty object to store cookies accumulated during the session.
3. Sets this.sessionId to null (no active session yet).
4. Sets this.sessionExpiresAt to null (no expiration until session starts).
5. Sets this.sessionProfile to null (no browser profile until session starts).
6. Sets this.browserSpeed from the config or defaults to "instant".
7. Sets this.force to true only if config.force === true, otherwise false.
8. Calculates this.sessionTime by clamping the provided value between 0.5 and 5 minutes (default: 2).
9. Creates a new BrowserAPI instance at this.browser, passing the session instance as the context.

Note that construction does not start a session on the server. The session is only created when you explicitly call start(). This separation allows you to configure the instance and perform pre-flight checks (like balance verification) before consuming a session slot.

Session Lifecycle

Every BBRESession follows a predictable lifecycle: construct, start, perform work, and close. Understanding this lifecycle is essential for writing reliable session-based code and avoiding resource leaks. The BBRE system enforces a limit of 10 active sessions per account, so failing to close sessions properly can prevent you from creating new ones.

Lifecycle Stages

1. CONSTRUCT    new BBRESession(config)     Local instance created, no server session
2. START        await session.start()       Server session created, browser allocated
3. WORK         await session.request(...)  Send requests, use browser, manage cookies
                await session.browser.navigate(...)
                await session.submitForm(...)
4. CLOSE        await session.close()       Server session terminated, resources freed

Stage 1 - Construct: You create a BBRESession instance with your configuration. At this point, no server resources are consumed. The instance is configured but idle. You can call inherited methods like getBalance() or getAccountInfo() to perform pre-flight checks before starting the session.

Stage 2 - Start: Calling start() creates a session on the BBRE server. The server allocates a browser instance, generates a browser profile (fingerprint), and returns a session ID and expiration timestamp. The BBRESession instance stores these values locally. From this point, the session is active and consuming one of your 10 available session slots.

Stage 3 - Work: This is where you perform your actual tasks. You can send HTTP requests through the session using request(), automate browser actions using this.browser methods, submit forms using submitForm(), run multi-step workflows using runSteps(), or check pages using checkPage(). All requests within this stage share the same cookies and browser identity. Cookies received from responses are automatically merged into the session cookie store.

Stage 4 - Close: Calling close() terminates the server-side session, releases the browser instance, and resets the local state (session ID, cookies, profile all set to null). The session slot becomes available for new sessions. If you do not call close(), the session will eventually expire based on the sessionTime configuration, but it is always better to close explicitly.

Basic Lifecycle Example

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sessionTime: 3
});

async function runWorkflow() {
  try {
    await session.start();
    console.log("Session started:", session.getSessionId());

    await session.browser.navigate("https://example.com/login");
    await session.browser.fill("#email", "[email protected]");
    await session.browser.fill("#password", "securepassword");
    await session.browser.click("#login-button");
    await session.browser.waitForSelector(".dashboard");

    const response = await session.request({
      url: "https://example.com/api/profile",
      method: "GET"
    });

    console.log("Profile data:", response.data);
  } finally {
    await session.close();
    console.log("Session closed");
  }
}

runWorkflow();

Lifecycle with Pre-flight Checks

Before starting a session, it is good practice to verify that your account has sufficient balance and available session slots. This prevents wasting time on session creation that would fail due to account limitations.

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sensibility: "medium"
});

async function safeWorkflow() {
  const { account, statistics } = await session.getAccountInfo();

  if (account.status !== "active") {
    console.log("Account is not active:", account.status);
    return;
  }

  if (account.balance < 5) {
    console.log("Low balance:", account.balance);
    return;
  }

  if (statistics.activeSessions >= 10) {
    console.log("No available session slots");
    return;
  }

  try {
    await session.start();
    console.log("Session active, ID:", session.getSessionId());

    await session.browser.navigate("https://example.com");
    const title = await session.browser.getTitle();
    console.log("Page title:", title);
  } finally {
    await session.close();
  }
}

safeWorkflow();

Session State Management

The BBRESession class maintains several pieces of state that are updated throughout the session lifecycle. Understanding what state is tracked and how it changes helps you write predictable session-based code.

State Properties

Cookie Persistence

One of the key features of BBRESession is automatic cookie persistence. When you send a request through the session's request() method, any cookies returned in the response are automatically merged into the sessionCookies store. On the next request, these cookies are automatically included along with any cookies you have set manually. This means you do not need to manually extract and re-send cookies between requests, which is essential for workflows that involve authentication, CSRF tokens, or any server-side state tracked via cookies.

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive"
});

async function cookieExample() {
  try {
    await session.start();

    const loginResponse = await session.request({
      url: "https://example.com/api/login",
      method: "POST",
      body: { username: "user", password: "pass" }
    });

    console.log("Cookies after login:", session.getCookies());

    const dashboardResponse = await session.request({
      url: "https://example.com/api/dashboard",
      method: "GET"
    });

    console.log("Dashboard data:", dashboardResponse.data);

    session.setCookie("custom_preference", "dark_mode");
    console.log("All cookies:", session.getCookies());
  } finally {
    await session.close();
  }
}

cookieExample();

Profile Tracking

When a session starts, the BBRE engine generates a browser fingerprint profile for the session's browser instance. This profile contains detailed information about the simulated browser environment, including the user agent string, platform, screen resolution, device memory, CPU cores, GPU renderer, timezone, locale, and more. The profile is stored locally in sessionProfile and updated whenever a browser action returns new profile data. You can access the full profile with getProfile() or get a simplified summary with getProfileSummary().

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive"
});

async function profileExample() {
  try {
    await session.start();

    console.log("Has profile:", session.hasProfile());

    const profile = session.getProfile();
    console.log("User Agent:", profile.userAgent);
    console.log("Platform:", profile.platform);
    console.log("Timezone:", profile.timezone);

    const summary = session.getProfileSummary();
    console.log("Screen:", summary.screen);
    console.log("Memory:", summary.deviceMemory);
    console.log("CPU Cores:", summary.cpuCores);
    console.log("GPU:", summary.gpu);
    console.log("Country:", summary.country);
    console.log("Mobile:", summary.mobile);
  } finally {
    await session.close();
  }
}

profileExample();

BrowserAPI Instance

Every BBRESession instance has a browser property that holds a BrowserAPI instance. This object is created during construction and provides a clean, method-based interface for browser automation actions. Instead of manually constructing browser action payloads and sending them through the API, you call methods like session.browser.navigate(), session.browser.click(), and session.browser.fill(). Each method internally calls the session's _browserAction() method, which sends the action to the BBRE API with the current session ID and browser speed setting.

The BrowserAPI class groups its methods into several categories: navigation (navigate, goto, reload, back, forward), interaction (click, fill, type, select, checkbox, fillForm, clear), page querying (getHtml, getText, getTitle, getUrl, find, findByText), waiting (wait, waitForElement, waitForText, waitForSelector), scrolling (scroll, scrollDown, scrollUp, scrollToTop, scrollToBottom), cookies (getCookies, setCookie, clearCookies), and advanced operations (screenshot, execute, evaluate).

Browser actions require the session to be in "adaptive" mode. If you created the session with "passive" mode, browser actions will fail because passive mode does not allocate a real browser instance on the server.

Using the BrowserAPI

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  browserSpeed: "fast"
});

async function browserExample() {
  try {
    await session.start();

    await session.browser.navigate("https://example.com");

    const title = await session.browser.getTitle();
    console.log("Page title:", title);

    const url = await session.browser.getUrl();
    console.log("Current URL:", url);

    await session.browser.click("a.products-link");
    await session.browser.waitForSelector(".product-list");

    const html = await session.browser.getHtml();
    console.log("Page HTML length:", html.length);

    await session.browser.scrollDown(500);
    await session.browser.wait(1);

    const text = await session.browser.getText(".product-count");
    console.log("Product count:", text);
  } finally {
    await session.close();
  }
}

browserExample();

BrowserAPI Method Categories

Force Mode vs Default Error Handling

The force configuration parameter controls how the session responds to browser action errors. This is one of the most important behavioral differences you need to understand when working with BBRESession, because it determines whether a single failed browser action can terminate your entire session.

Default Behavior (force: false)

When force is false (the default), the session operates in a "fail-safe" mode. If any browser action fails (for example, a click on a selector that does not exist, a navigation timeout, or a JavaScript execution error), the session automatically closes itself and throws an error with the prefix [SESSION_STOPPED]. This behavior protects you from continuing to work with a session that may be in an inconsistent state after an error.

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive"
});

async function defaultErrorHandling() {
  try {
    await session.start();
    await session.browser.navigate("https://example.com");

    await session.browser.click("#nonexistent-button");
  } catch (error) {
    console.log(error.message);
    console.log("Session active:", session.isActive());
  }
}

defaultErrorHandling();

Force Mode (force: true)

When force is true, browser action errors do not automatically close the session. Instead, the method returns a result object with success: false and an error property describing what went wrong. The session remains active, and you can continue sending actions or requests. This mode is useful for workflows where you expect some actions to fail (for example, checking whether an element exists by trying to click it) or where you want to implement your own error recovery logic.

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  force: true
});

async function forceErrorHandling() {
  try {
    await session.start();
    await session.browser.navigate("https://example.com");

    const result = await session.browser.click("#optional-popup-close");

    if (result.success === false) {
      console.log("Popup not found, continuing:", result.error);
    }

    console.log("Session still active:", session.isActive());

    await session.browser.click("#main-content-link");
    await session.browser.waitForSelector(".content-loaded");

    console.log("Workflow completed successfully");
  } finally {
    await session.close();
  }
}

forceErrorHandling();

Choosing Between Default and Force Mode

Browser Speed Settings

The browserSpeed setting controls the timing of browser actions within the session. Every browser action sent through this.browser or through the high-level methods (submitForm(), runSteps(), interact(), checkPage()) includes the current browser speed as a _speed parameter. The BBRE engine uses this parameter to add appropriate delays between actions, making the browser behavior appear more or less human-like depending on the setting.

Speed Options

Changing Speed During a Session

You can change the browser speed at any point during a session using the setBrowserSpeed() method. This is useful when different parts of your workflow have different speed requirements. For example, you might use "instant" for initial navigation and "human" for form filling on a sensitive page.

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  browserSpeed: "instant"
});

async function variableSpeedWorkflow() {
  try {
    await session.start();

    console.log("Current speed:", session.getBrowserSpeed());
    await session.browser.navigate("https://example.com");

    session.setBrowserSpeed("human");
    console.log("Speed changed to:", session.getBrowserSpeed());

    await session.browser.fill("#search-input", "product name");
    await session.browser.click("#search-button");
    await session.browser.waitForSelector(".search-results");

    session.setBrowserSpeed("instant");
    const html = await session.browser.getHtml();
    console.log("Results HTML length:", html.length);
  } finally {
    await session.close();
  }
}

variableSpeedWorkflow();

Session Time Configuration

The sessionTime parameter controls how long the server-side session remains active before it expires due to inactivity. The value is specified in minutes and must be between 0.5 and 5. If you provide a value outside this range, it is automatically clamped: values below 0.5 become 0.5, and values above 5 become 5. The default is 2 minutes.

When start() is called, the session time is converted from minutes to seconds and passed as the timeout parameter to the createSession() API call. The server uses this value to set the session expiration. If no requests or browser actions are sent within this time window, the session expires automatically and the browser instance is released.

You can also override the session time for a specific start() call by passing a timeout option (in seconds, capped at 300) directly to the start() method. This override takes precedence over the sessionTime constructor parameter for that particular session.

Session Time Examples

const { BBRESession } = require("mydisctsolver-bbre");

const quickSession = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sessionTime: 0.5
});

const standardSession = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sessionTime: 2
});

const longSession = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sessionTime: 5
});

async function sessionTimeDemo() {
  try {
    await quickSession.start();
    console.log("Quick session (30 seconds) started");
    await quickSession.browser.navigate("https://example.com");
    const title = await quickSession.browser.getTitle();
    console.log("Title:", title);
  } finally {
    await quickSession.close();
  }
}

sessionTimeDemo();

Overriding Session Time in start()

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sessionTime: 2
});

async function overrideTimeout() {
  try {
    await session.start({ timeout: 60 });
    console.log("Session started with 60-second timeout override");

    await session.browser.navigate("https://example.com");
    console.log("Page loaded");
  } finally {
    await session.close();
  }
}

overrideTimeout();

Complete Method Reference

The following tables list all methods available on a BBRESession instance, grouped by category. This includes both methods defined directly on BBRESession and methods inherited from BBREClient. Each method links to its detailed documentation page where you can find full parameter descriptions, return types, and usage examples.

Session Lifecycle Methods

Session Request Methods

Browser Configuration Methods

Profile Methods

Session Info Methods

Cookie Management Methods

BrowserAPI Methods (via session.browser)

Quick Start Example

The following example demonstrates a complete session workflow: creating a session, navigating to a website, filling out a login form, extracting data from the authenticated page, and closing the session. This covers the most common use case for BBRESession and shows how the different components work together.

Complete Login and Data Extraction Workflow

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sensibility: "medium",
  browserSpeed: "fast",
  sessionTime: 3
});

async function loginAndExtractData() {
  try {
    const balance = await session.getBalance();
    console.log("Account balance:", balance);

    if (balance < 2) {
      console.log("Insufficient balance for session workflow");
      return;
    }

    const sessionData = await session.start();
    console.log("Session ID:", sessionData.sessionId);
    console.log("Expires at:", sessionData.expiresAt);

    await session.browser.navigate("https://example.com/login");
    console.log("Login page loaded");

    await session.browser.fill("#username", "myuser");
    await session.browser.fill("#password", "mypassword");
    await session.browser.click("#login-submit");

    await session.browser.waitForSelector(".dashboard-container");
    console.log("Login successful, dashboard loaded");

    const welcomeText = await session.browser.getText(".welcome-message");
    console.log("Welcome message:", welcomeText);

    const response = await session.request({
      url: "https://example.com/api/user/orders",
      method: "GET"
    });

    console.log("Orders count:", response.data.length);
    console.log("Cookies accumulated:", Object.keys(session.getCookies()).length);

    if (session.hasProfile()) {
      const summary = session.getProfileSummary();
      console.log("Browser profile:", summary.userAgent);
      console.log("Screen:", summary.screen);
    }
  } catch (error) {
    console.log("Workflow error:", error.message);
  } finally {
    await session.close();
    console.log("Session closed, active:", session.isActive());
  }
}

loginAndExtractData();

Form Submission with submitForm()

For simpler form submission workflows, you can use the submitForm() method which handles navigation, field filling, and submission in a single call.

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  browserSpeed: "human",
  sessionTime: 2
});

async function submitContactForm() {
  try {
    await session.start();

    const result = await session.submitForm("https://example.com/contact", {
      fields: {
        "#name": "John Smith",
        "#email": "[email protected]",
        "#message": "Hello, I have a question about your product."
      },
      select: {
        "#department": "sales"
      },
      checkbox: "I agree to the terms",
      submit: "#send-button",
      waitFor: "Thank you for your message"
    });

    console.log("Form submitted successfully:", result.success);
    console.log("Final URL:", result.finalUrl);
    console.log("Steps completed:", result.stepsCompleted);
  } finally {
    await session.close();
  }
}

submitContactForm();

Multi-Step Workflow with runSteps()

For complex workflows that involve multiple pages and interactions, use runSteps() to define a sequence of actions that execute in order.

const { BBRESession } = require("mydisctsolver-bbre");

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  browserSpeed: "fast",
  force: true,
  sessionTime: 4
});

async function multiStepWorkflow() {
  try {
    await session.start();

    const result = await session.runSteps("https://example.com/search", [
      { fill: { "#search-box": "laptop computers" } },
      { click: "#search-button" },
      { waitFor: ".search-results" },
      { scrollDown: 500 },
      { wait: 1 },
      { click: ".product-card:first-child a" },
      { waitFor: ".product-details" }
    ]);

    console.log("Steps completed:", result.stepsCompleted, "/", result.totalSteps);
    console.log("Final URL:", result.finalUrl);

    const productTitle = await session.browser.getText("h1.product-title");
    const productPrice = await session.browser.getText(".product-price");
    console.log("Product:", productTitle);
    console.log("Price:", productPrice);
  } finally {
    await session.close();
  }
}

multiStepWorkflow();

BBRESession vs BBREClient

Choosing between BBRESession and BBREClient depends on your specific use case. The following comparison table highlights the key differences between the two classes to help you make the right choice.

When to Use BBREClient

Use BBREClient when you need to make independent HTTP requests that do not require shared state. Common scenarios include fetching public web pages, calling APIs that do not require session cookies, running batch requests against multiple different URLs, checking website availability, and any workflow where each request is self-contained. BBREClient is simpler to use because it does not require session lifecycle management, and it does not consume session slots on your account.

When to Use BBRESession

Use BBRESession when your workflow requires maintaining state between requests or when you need browser automation capabilities. Common scenarios include logging into websites and performing authenticated actions, filling out multi-step forms that span multiple pages, navigating through paginated content while preserving session cookies, interacting with JavaScript-heavy applications that require a real browser, and any workflow where the target website needs to see a consistent visitor identity across multiple interactions.

Using Both Together

Since BBRESession extends BBREClient, you can use a single BBRESession instance for both session-based and standalone operations. However, if your application has distinct workflows that require different configurations, you might want to create separate instances.

const BBREClient = require("mydisctsolver-bbre");
const { BBRESession } = require("mydisctsolver-bbre");

const client = new BBREClient({
  apiKey: "YOUR_API_KEY",
  mode: "passive",
  sensibility: "low"
});

const session = new BBRESession({
  apiKey: "YOUR_API_KEY",
  mode: "adaptive",
  sensibility: "high",
  browserSpeed: "human"
});

async function combinedWorkflow() {
  const publicData = await client.get("https://example.com/api/public/products");
  console.log("Public products:", publicData.data.length);

  try {
    await session.start();
    await session.browser.navigate("https://example.com/login");
    await session.browser.fill("#email", "[email protected]");
    await session.browser.fill("#password", "password123");
    await session.browser.click("#login-btn");
    await session.browser.waitForSelector(".dashboard");

    const privateData = await session.request({
      url: "https://example.com/api/private/orders",
      method: "GET"
    });
    console.log("Private orders:", privateData.data.length);
  } finally {
    await session.close();
  }
}

combinedWorkflow();

Best Practices

Common Issues

Related Documentation

Explore these related pages to learn more about the BBRESession class methods, BrowserAPI capabilities, and the underlying API endpoints that power session-based workflows.