MCP integrations

Call Model Context Protocol (MCP) servers alongside Stagehand’s primitives

Stagehand v4 does not include an autonomous agent or a general-purpose MCP client. To call third-party MCP tools alongside Stagehand, orchestrate both from your own code as shown below.

Stagehand also provides experimental integrations that expose a persistent Stagehand browser to CrewAI, Deep Agents, Mastra, and the Vercel AI SDK over MCP. The Eve integration exposes the same tools natively.

Stagehand integrations

Give an agent the run, snapshot, and screenshot browser tools.

Calling MCP servers from your code

Interleave your tool results with Stagehand’s primitives. Because v4 has no autonomous loop, you are already writing the orchestration, so a tool call is one more step in the sequence.

TypeScript

// Your MCP client, your credentials, your control flow
const searchResults = await mcpClient.callTool("web_search", {
  query: "browserbase pricing",
});

// Hand the result to Stagehand as an ordinary instruction
await page.goto(searchResults.topUrl);

const { data } = await stagehand.extract(
  "extract the pricing tiers",
  z.object({ pricing: z.array(z.object({ tier: z.string(), price: z.string() })) }),
);

Python

# Your MCP client, your credentials, your control flow
search_results = await mcp_client.call_tool(
    "web_search", {"query": "browserbase pricing"}
)

# Hand the result to Stagehand as an ordinary instruction
await page.goto(search_results["top_url"])


class Tier(BaseModel):
    tier: str
    price: str


class Pricing(BaseModel):
    pricing: list[Tier]


result = await stagehand.extract(
    instruction="extract the pricing tiers",
    schema=Pricing,
)
pricing = result.data

Go

// Your MCP client, your credentials, your control flow
searchResults, err := mcpClient.CallTool(ctx, "web_search", map[string]any{
	"query": "browserbase pricing",
})
if err != nil {
	return err
}

// Hand the result to Stagehand as an ordinary instruction
if _, err := page.Goto(ctx, searchResults.TopURL, nil); err != nil {
	return err
}

type tier struct {
	Tier  string `json:"tier"`
	Price string `json:"price"`
}

type pricing struct {
	Pricing []tier `json:"pricing"`
}


extracted, err := stagehand.Extract[pricing](
	ctx,
	client,
	"extract the pricing tiers",
	nil,
)
if err != nil {
	return err
}

for _, t := range extracted.Data.Pricing {
	fmt.Println(t.Tier, t.Price)
}

MCP is still useful on the authoring side: wire the Stagehand docs MCP server into your coding assistant so it generates correct v4 code. See AI Rules.

Next steps

Act

Perform a single action with natural language

Extract

Pull typed data out of any page

AI rules

MCP servers for your coding assistant