Deploy a Function

You can publish a Function from a local TypeScript project or from the Browserbase Playground. Both paths create a Function version that you invoke through the API.

Functions are currently only available in the us-west-2 region.

Deploy from the CLI

Use the CLI when you want version control, custom dependencies, or local editor tooling. If you don’t have a local project yet, follow the Functions quickstart.

Define the Function in your entrypoint

Stagehand
Playwright

Node.js

// index.ts
import { defineFn } from "@browserbasehq/sdk-functions";
import { browserbase, Stagehand } from "@browserbasehq/stagehand";
import { z } from "zod/v4";

defineFn(
  "page-title",
  async (context, params) => {
    const browser = await browserbase.connect({
      // The local dev server has no Secrets, so fall back to .env.
      apiKey: context.secrets.BROWSERBASE_API_KEY ?? process.env.BROWSERBASE_API_KEY!,
      sessionId: context.session.id,
    });
    // In this example, Stagehand uses the Model Gateway where Browserbase charges for the tokens
    const stagehand = await Stagehand.create({ browser });
    const page = (await browser.context.activePage())!;

    await page.goto(params.url);
    const { data } = await stagehand.extract(
      "Extract the page title",
      z.object({ title: z.string() }),
    );

    await stagehand.close();
    return { title: data.title };
  },
  {
    parametersSchema: z.object({ url: z.string().url() }),
    // The ID from `browse cloud extensions upload`. Stagehand needs its extension in the session.
    sessionConfig: { extensionId: "your-extension-id" },
  },
);

Node.js

// index.ts
import { defineFn } from "@browserbasehq/sdk-functions";
import { chromium } from "playwright-core";

defineFn("page-title", async (context, params) => {
  const browser = await chromium.connectOverCDP(
    context.session.connectUrl,
  );
  const page = browser.contexts()[0]!.pages()[0]!;

  await page.goto(params.url);

  return { title: await page.title() };
});

Publish the entrypoint

browse functions publish index.ts

The command builds the Function and prints its Function ID (builtFunctions[].id). Save that ID for invoke.

Attach the Secrets

If the Function reads Secrets, attach them. The Stagehand example reads BROWSERBASE_API_KEY:

browse functions secrets attach FUNCTION_ID SECRET_ID

Attach each Secret one time. New versions of the Function keep the attached Secrets.

With pnpm 11 or later, add this pnpm-workspace.yaml to the Function project directory, or installs and builds fail. The Functions initializer creates it for you.

allowBuilds:
  esbuild: true

If the build fails, open the build in the Browserbase dashboard to see the build logs. Publishing again with the same Function name creates a new version. Callers keep using the same Function ID. To ship several Functions from one entrypoint, see publish multiple Functions.

Deploy from the Playground

The Playground lets you write and publish a Function without a local project. Test Stagehand or Playwright code in a live browser, define input parameters, then publish.

Open the Playground

Open the Browserbase dashboard, then select Playground.

Write the browser script

The editor starts with a Stagehand template. Write the browser logic that the Function will run:

Playground

import { localBrowser, Stagehand } from "@browserbasehq/stagehand";

const browser = await localBrowser.connect({ cdpUrl: connectUrl });
const stagehand = await Stagehand.create({ browser });
const page = await browser.context.activePage();

await page.goto("https://example.com");
await stagehand.act("Click the More information link");

return {
  url: await page.url(),
  title: await page.title(),
};

The Playground provides connectUrl, sessionId, apiKey, and z as globals. Use Convert to Stagehand to convert a Playwright script.

The Playground does not compile TypeScript. Your code runs as JavaScript, so type annotations, interfaces, and casting will throw a SyntaxError. When you publish, the Playground puts your script into an index.ts file.

Test the script

Select Run. The Playground creates a browser session, runs the script, displays its output, and opens a live browser view.Use the console output and live view to fix the script before you publish it.

Define Function parameters

Open Deploy, then add inputs under Function Parameters:

Each parameter has a name and an optional default value. The published Function receives the values through params:

Playground

await stagehand.act(`Search for "${params.searchQuery}"`);

Run doesn’t populate params. Use a literal value while you test, then replace it with params.<name> before you publish. You can define up to eight parameters.

Publish the Function

In the Deploy panel:

Enter a Function name.
Select Deploy as Function.

After the build completes, the Playground shows an invoke command and a link to the Function details.

Publishing the same Function name creates a new version of the existing Function. Move to a local project and deploy from the CLI when you need version control, multiple files, custom dependencies, or local editor tooling.

After you deploy

Open Functions in the dashboard to:

Copy the Function ID and invoke command.
Review builds, versions, and invocation history.
Inspect invocation logs and browser sessions.
Delete a Function.

Invoke a Function

Pass parameters and retrieve asynchronous results.

Write a Function

Configure schemas, browser settings, and multiple Functions.

Welcome

Platform

Use cases

Optimization

Account

Deploy from the CLI

Deploy from the Playground

After you deploy

Invoke a Function

Write a Function

​Deploy from the CLI

​Deploy from the Playground

​After you deploy

Invoke a Function

Write a Function

Deploy from the CLI

Deploy from the Playground

After you deploy