what changed

import asyncio
import os

from pydantic import BaseModel
from stagehand import Stagehand, local_browser


class Invoice(BaseModel):
    number: str
    amount: float
    paid: bool


class Invoices(BaseModel):
    invoices: list[Invoice]


async def main() -> None:
    # Cookies persist in ./browser-data, so the next run starts already signed in
    browser = await local_browser.launch(user_data_dir="./browser-data")
    try:
        stagehand = await Stagehand.create(
            browser=browser,
            model="openai/gpt-5.4-mini",
            model_api_key=os.environ["OPENAI_API_KEY"],
        )
        try:
            page = (await browser.context.pages())[0]
            await page.goto("https://app.example.com/login")

            # observe() returns real selectors, so credentials never reach the model
            email = await stagehand.observe("find the email input")
            password = await stagehand.observe("find the password input")
            await page.locator(email.data[0].selector).fill(os.environ["APP_EMAIL"])
            await page.locator(password.data[0].selector).fill(os.environ["APP_PASSWORD"])

            # act() self-heals when the site redesigns its form
            await stagehand.act("click the sign in button")
            await stagehand.act("open the billing page")

            # extract() returns schema-validated data
            result = await stagehand.extract(
                "extract every invoice in the table",
                Invoices,
            )
            print(result.data.invoices)
        finally:
            await stagehand.close()
    finally:
        await browser.close()


asyncio.run(main())

package main

import (
    "context"
    "errors"
    "fmt"
    "log"
    "os"

    stagehand "github.com/browserbase/stagehand/packages/sdk-go/v4"
)

type invoice struct {
    Number string  `json:"number"`
    Amount float64 `json:"amount"`
    Paid   bool    `json:"paid"`
}

type invoices struct {
    Invoices []invoice `json:"invoices"`
}

func main() {
    if err := run(context.Background()); err != nil {
        log.Fatal(err)
    }
}

func run(ctx context.Context) (err error) {
    // Cookies persist in ./browser-data, so the next run starts already signed in
    browser, err := stagehand.LaunchLocalBrowser(ctx, &stagehand.LocalBrowserLaunchOptions{
        UserDataDir: "./browser-data",
    })
    if err != nil {
        return err
    }
    defer func() { err = errors.Join(err, browser.Close(ctx)) }()

    modelAPIKey := os.Getenv("OPENAI_API_KEY")
    client, err := stagehand.Create(ctx, stagehand.CreateOptions{
        Browser: browser,
        Model: &stagehand.ModelConfig{
            ModelName: "openai/gpt-5.4-mini",
            APIKey:    &modelAPIKey,
        },
    })
    if err != nil {
        return err
    }
    defer func() { err = errors.Join(err, client.Close(ctx)) }()

    browserContext, err := browser.Context()
    if err != nil {
        return err
    }
    pages, err := browserContext.Pages(ctx)
    if err != nil {
        return err
    }
    page := pages[0]
    if _, err := page.Goto(ctx, "https://app.example.com/login", nil); err != nil {
        return err
    }

    // Observe returns real selectors, so credentials never reach the model
    emailInstruction := "find the email input"
    email, err := client.Observe(ctx, &emailInstruction, nil)
    if err != nil {
        return err
    }
    if err := page.Locator(email.Data[0].Selector).Fill(ctx, os.Getenv("APP_EMAIL")); err != nil {
        return err
    }

    passwordInstruction := "find the password input"
    password, err := client.Observe(ctx, &passwordInstruction, nil)
    if err != nil {
        return err
    }
    if err := page.Locator(password.Data[0].Selector).Fill(ctx, os.Getenv("APP_PASSWORD")); err != nil {
        return err
    }

    // Act self-heals when the site redesigns its form
    if _, err := client.Act(ctx, stagehand.ActInstruction("click the sign in button"), nil); err != nil {
        return err
    }
    if _, err := client.Act(ctx, stagehand.ActInstruction("open the billing page"), nil); err != nil {
        return err
    }

    // Extract returns data decoded into a Go type
    extracted, err := stagehand.Extract[invoices](
        ctx,
        client,
        "extract every invoice in the table",
        nil,
    )
    if err != nil {
        return err
    }
    fmt.Println(extracted.Data.Invoices)

    return nil
}

pip install stagehand

go get github.com/browserbase/stagehand/packages/sdk-go/v4@v4.0.0

import os

from stagehand import Stagehand, browserbase

browser = await browserbase.launch(api_key=os.environ["BROWSERBASE_API_KEY"])

# No model configuration: the Model Gateway picks the cheapest model for each action
# cache=True: identical calls come back from Browserbase, no tokens spent
stagehand = await Stagehand.create(browser=browser, cache=True)

browser, err := stagehand.LaunchBrowserbase(ctx, stagehand.BrowserbaseLaunchOptions{
    APIKey: os.Getenv("BROWSERBASE_API_KEY"),
})
if err != nil {
    return err
}

// No model configuration: the Model Gateway picks the cheapest model for each action
// CacheEnabled(true): identical calls come back from Browserbase, no tokens spent
cache := stagehand.CacheEnabled(true)
client, err := stagehand.Create(ctx, stagehand.CreateOptions{
    Browser: browser,
    Cache:   &cache,
})
if err != nil {
    return err
}

{
  "mcpServers": {
    "browserbase": {
      "url": "https://mcp.browserbase.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_BROWSERBASE_API_KEY" }
    }
  }
}