Migrate Steel to Notte

What changes

Steel: Steel is a browser API with managed cloud and self-hosted deployment paths. Its current documentation covers persistent profiles, a credential API, session replay and agent observability.

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.steel.dev [1] ↗docs.steel.dev [2] ↗docs.steel.dev [3] ↗docs.steel.dev [4] ↗docs.steel.dev [5] ↗docs.steel.dev [6] ↗docs.notte.cc [7] ↗docs.notte.cc [8] ↗docs.notte.cc [9] ↗docs.notte.cc [10] ↗docs.notte.cc [11] ↗docs.notte.cc [12] ↗

1. Replace session ownership

Steel sessions expose browser connection details for existing automation code. Create and release the owned session through Steel's lifecycle API; a browser library is the controller, not the infrastructure scheduler.

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.steel.dev [1] ↗docs.notte.cc [2] ↗

2. Re-establish saved state and authentication

Steel: The Profiles API documents reusable browser context, cookies, extensions, credentials and browser settings. Steel also documents lighter auth-context reuse, which should not be confused with a complete profile.

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.steel.dev [1] ↗docs.notte.cc [2] ↗docs.notte.cc [3] ↗

3. Move the execution layer deliberately

Steel: The reviewed browser documentation establishes sessions, profiles and credentials. It does not establish a hosted Python handler with deployment and invocation APIs. An external worker can control a Steel browser; price and operate that worker separately.

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.steel.dev [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