Using multiple tabs

Web applications often open a new tab when someone clicks a button or link, and a script that only watches the original tab breaks when the content lands elsewhere. Stagehand follows the new tab for you.

The Stagehand page

The active page is whichever tab Chrome has focused in its last-focused window, so a tab the browser opens and activates becomes the target on its own. act(), observe(), and extract() all default to that page. The usual patterns keep working:

TypeScript
Python
Go

const page = await browser.context.activePage();
await page.goto("https://example.com");
await stagehand.act("click the button that opens a new tab");

// Stagehand now operates on the new tab automatically
const { data } = await stagehand.extract(
  "get data from new tab",
  z.object({ value: z.string() }),
);
console.log(data.value);

page = await browser.context.active_page()
await page.goto("https://example.com")
await stagehand.act("click the button that opens a new tab")


class Data(BaseModel):
    value: str


# Stagehand now operates on the new tab automatically
result = await stagehand.extract(
    instruction="get data from new tab",
    schema=Data,
)
print(result.data.value)

page, err := browserContext.ActivePage(ctx)
if err != nil {
	return err
}
if page == nil {
	return errors.New("Stagehand has no active page")
}
if _, err := page.Goto(ctx, "https://example.com", nil); err != nil {
	return err
}
if _, err := client.Act(ctx, stagehand.ActInstruction("click the button that opens a new tab"), nil); err != nil {
	return err
}

type data struct {
	Value string `json:"value"`
}


// Stagehand now operates on the new tab automatically
extracted, err := stagehand.Extract[data](ctx, client, "get data from new tab", nil)
if err != nil {
	return err
}

fmt.Println(extracted.Data.Value)

Important: The page object you captured before the click still refers to the original tab. Re-read the active page, or hold an explicit reference to each tab, when you need to reach back to it.

Manual page management

For more control or multitab workflows, you can manage multiple tabs explicitly. Set the active page when you want the default target to follow you:

TypeScript
Python
Go

// Create a second page
await browser.context.newPage();
const pages = await browser.context.pages();

const githubPage = pages[0];
const pythonPage = pages[1];

// Navigate each page to different repositories
await githubPage.goto("https://github.com/browserbase/stagehand");
await pythonPage.goto("https://github.com/browserbase/stagehand-python");

// Extract data from both pages simultaneously
const starsSchema = z.object({ stars: z.number() });
const [stagehandStars, stagehandPythonStars] = await Promise.all([
  stagehand.extract("extract the repository stars", starsSchema, { page: githubPage }),
  stagehand.extract("extract the repository stars", starsSchema, { page: pythonPage }),
]);

console.log(`Stagehand stars: ${stagehandStars.data.stars}`);
console.log(`Stagehand-Python stars: ${stagehandPythonStars.data.stars}`);

// Make one of them the default target for later calls
await browser.context.setActivePage(githubPage);

import asyncio

from pydantic import BaseModel

class Stars(BaseModel):
    stars: int


# Create a second page
await browser.context.new_page()
pages = await browser.context.pages()

github_page = pages[0]
python_page = pages[1]

# Navigate each page to different repositories
await github_page.goto("https://github.com/browserbase/stagehand")
await python_page.goto("https://github.com/browserbase/stagehand-python")

# Extract data from both pages simultaneously
stagehand_stars, stagehand_python_stars = await asyncio.gather(
    stagehand.extract(
        instruction="extract the repository stars", schema=Stars, page=github_page
    ),
    stagehand.extract(
        instruction="extract the repository stars", schema=Stars, page=python_page
    ),
)

print(f"Stagehand stars: {stagehand_stars.data.stars}")
print(f"Stagehand-Python stars: {stagehand_python_stars.data.stars}")

# Make one of them the default target for later calls
await browser.context.set_active_page(github_page)

type stars struct {
	Stars int `json:"stars"`
}


// Create a second page
if _, err := browserContext.NewPage(ctx); err != nil {
	return err
}
pages, err := browserContext.Pages(ctx)
if err != nil {
	return err
}

githubPage, pythonPage := pages[0], pages[1]

// Navigate each page to different repositories
if _, err := githubPage.Goto(ctx, "https://github.com/browserbase/stagehand", nil); err != nil {
	return err
}
if _, err := pythonPage.Goto(ctx, "https://github.com/browserbase/stagehand-python", nil); err != nil {
	return err
}

// Extract data from both pages concurrently
group, groupCtx := errgroup.WithContext(ctx)
var stagehandStars, stagehandPythonStars stars

group.Go(func() error {
	result, err := stagehand.Extract[stars](groupCtx, client, "extract the repository stars",
		&stagehand.StagehandClientExtractOptions{Page: githubPage})
	stagehandStars = result.Data
	return err
})
group.Go(func() error {
	result, err := stagehand.Extract[stars](groupCtx, client, "extract the repository stars",
		&stagehand.StagehandClientExtractOptions{Page: pythonPage})
	stagehandPythonStars = result.Data
	return err
})
if err := group.Wait(); err != nil {
	return err
}

fmt.Printf("Stagehand stars: %d\n", stagehandStars.Stars)
fmt.Printf("Stagehand-Python stars: %d\n", stagehandPythonStars.Stars)

// Make one of them the default target for later calls
if err := browserContext.SetActivePage(ctx, githubPage); err != nil {
	return err
}

Locators belong to the page they were created on. page.locator(selector) carries that page’s identity, so a locator from one tab never resolves against another.

Next steps

Act

Target a specific tab with the page option on any primitive.

Working with iframes

Stagehand traverses iframes automatically. Scope with a selector when you need to narrow the snapshot.

Browser configuration

Manage browser contexts and sessions for complex automation scenarios.

Logging & debugging

Set log levels and read structured records while you debug.

First steps

The basics

Configuration

Best practices

Migration guide

SDK reference

Using multiple tabs

The Stagehand page

Manual page management

Next steps

Act

Working with iframes

Browser configuration

Logging & debugging

​The Stagehand page

​Manual page management

​Next steps

Act

Working with iframes

Browser configuration

Logging & debugging

The Stagehand page

Manual page management

Next steps