Migrate Browser Use to Notte

What changes

Browser Use: Browser Use has separate hosted-browser and hosted-agent paths. For browser infrastructure, create a browser and connect your own code over CDP. Profiles and secret bindings handle different parts of authenticated work.

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.browser-use.com [1] ↗docs.browser-use.com [2] ↗docs.browser-use.com [3] ↗docs.browser-use.com [4] ↗docs.notte.cc [5] ↗docs.notte.cc [6] ↗docs.notte.cc [7] ↗docs.notte.cc [8] ↗docs.notte.cc [9] ↗docs.notte.cc [10] ↗

1. Replace session ownership

The V4 browser API creates a browser with a CDP URL. Your Playwright or Browser Use code can connect directly. Stopping the browser requires the browser API; closing CDP alone does not stop it.

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.browser-use.com [1] ↗docs.notte.cc [2] ↗

2. Re-establish saved state and authentication

Browser Use: Profiles persist cookies, local storage and login state between browsers. Browser settings select a profile for a run. A session's conversation history and a profile's browser state are different resources.

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.browser-use.com [1] ↗docs.notte.cc [2] ↗docs.notte.cc [3] ↗

3. Move the execution layer deliberately

Browser Use: The cloud offers hosted-agent runs and separately created browsers. The reviewed browser documentation does not establish a deploy-your-own Python Function equivalent. Keep an external script runner separate from a hosted agent when comparing execution ownership.

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.browser-use.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