Migrate Browserbase to Notte

What changes

Browserbase: Browserbase provides managed browser sessions and TypeScript Functions that run next to a browser. Contexts preserve browser state, while its identity and secret tools address different parts of the sign-in workflow.

Notte: Notte combines cloud browser sessions with deployed Python automations and website authentication tools. You can control the browser over CDP or use Notte's actions, then deploy repeated work as a Function.

Port the browser actions separately from the provider integration. A session endpoint, a saved profile identifier and a managed login connection belong to the provider that created them; replacing an API key does not migrate those resources.

Map the resource contract

Sources: docs.browserbase.com [1] ↗docs.browserbase.com [2] ↗docs.browserbase.com [3] ↗docs.browserbase.com [4] ↗docs.browserbase.com [5] ↗docs.notte.cc [6] ↗docs.notte.cc [7] ↗docs.notte.cc [8] ↗docs.notte.cc [9] ↗docs.notte.cc [10] ↗docs.notte.cc [11] ↗

1. Replace session ownership

Create a managed browser session and connect a supported browser library to its connection URL. The session API and the browser connection have separate lifecycles.

Create an owned browser session, connect Playwright or Puppeteer over CDP, and stop the session when the work finishes. Browser lifecycle management remains necessary even when the control socket disconnects.

Create the target session through its documented API, keep its returned identifier with the application job, and implement the target release path before testing failures.

Sources: docs.browserbase.com [1] ↗docs.notte.cc [2] ↗

2. Re-establish saved state and authentication

Browserbase: Contexts preserve browser data between sessions. Associate the intended Context with each user's browser and decide which sessions may update it; a Context is distinct from a live running session.

Notte: Profiles save cookies, local storage and session storage. Sessions start with fresh state by default. Persisting a profile writes state back when the session ends; a running session can also save its state explicitly.

Notte: Vaults substitute credential placeholders in supported browser actions outside the model context. Managed Auth checks requested saved connections before automation. Personas supply an inbox and optional phone number for verification workflows.

Use a supported export/import path only if both products document it. Otherwise establish an authorized login on the target and save its state there. Never reuse a source provider's resource ID as a target profile or connection.

Sources: docs.browserbase.com [1] ↗docs.notte.cc [2] ↗docs.notte.cc [3] ↗

3. Move the execution layer deliberately

Browserbase: A Function is TypeScript code published with an entry point. Invocation starts asynchronously, creates a browser, passes its connection URL to the handler, and stores the result, logs and session ID. Function webhooks report status changes.

Notte: Functions deploy Python code with a run() entry point. Invoke them over HTTP or with an SDK, inspect run history, and roll back code by redeploying an earlier version as the latest version.

Keep the existing runner for the first browser test when possible. If execution moves to a hosted Function or app action, separately port the entry point, dependencies, invocation, results and cancellation behavior.

Sources: docs.browserbase.com [1] ↗docs.notte.cc [2] ↗

Check the browser connection

Install playwright-core in your application and provision a session through the provider's documented creation flow. Run this smoke test from the intended controller region with the returned CDP endpoint. It checks connection and navigation, not login, rendering parity or a complete business workflow.

Keep browser connection URLs on your backend. After the test, release the owned session through the provider's API. Product-specific lifecycle APIs and profile identifiers are not portable between providers.

import { chromium } from "playwright-core";

// Provision the owned browser using the provider's documented session API.
// Keep the connection URL in your backend's secret environment.
const endpoint = process.env.BROWSER_CDP_URL;
if (!endpoint) throw new Error("Set BROWSER_CDP_URL for an owned session");

const browser = await chromium.connectOverCDP(endpoint);
try {
  const context = browser.contexts()[0] ?? await browser.newContext();
  const page = context.pages()[0] ?? await context.newPage();
  await page.goto("https://example.com", { waitUntil: "domcontentloaded" });
  if ((await page.title()) !== "Example Domain") {
    throw new Error("The browser did not reach the expected page");
  }
  console.log({ connected: true, expectedPage: true });
} finally {
  await browser.close();
  // Release the owned session with the provider's documented API as well.
  // A disconnected socket alone is not a portable session-cleanup contract.
}

Sources: playwright.dev ↗

4. Prove the same task still completes

After the connection smoke test, run the same authorized business workflow on both providers. Verify the account, output and expected website state. Record each provider's session identifier and the implementation version with its result.

• Test a fresh session and a second session with restored state.
• Exercise a controlled failure and check the retained evidence.
• Verify the target concurrency and duration entitlements.
• Stop the target execution and release the owned browser.
• Retain the source integration until the acceptance checks pass.

5. Recalculate costs and limits

The public plans list 5, 25 and 100 concurrent browser sessions, with custom limits on Enterprise. Session duration and concurrent capacity are separate plan limits; a larger technical API limit does not override the plan.

The public usage rates are $0.01 per browser-hour, $0.05 per Function-hour and $10 per GB of managed proxy traffic. Paid plans return their price as usage credits. Price the relevant meters and plan eligibility for the workload.

A saved profile restores browser state; it does not prove that a website still considers the user signed in. Use Managed Auth when the workflow needs connection readiness before it starts.

Sources: notte.cc [1] ↗

Keep comparing