Stagehand
Open-source SDK for building browser agents with AI primitives (Act, Extract, Observe, Agent) plus Playwright-style controls in TypeScript, Python, and Go.
Stagehand solves the specific problem that makes browser agents annoying in production: selectors break, pages bloat the context window, and remote drivers add latency. The v4 caching and network-level domain allowlist/blocklist matter more than the marketing — prompt injection is the real risk when your agent browses untrusted pages, and self-healing actions mean a redesign doesn't mean a rewrite. If your team writes TypeScript, Python, or Go and treats browser control as an engineering surface, this is a reasonable default over raw Playwright and Puppeteer. If you wanted no-code or a managed black-box agent with nothing to own, keep looking — the tradeoff is that you handle browser setup,
Verified 4d ago · liveness 78/100 · cite: rightaichoice.com/tools/stagehand
- Developers building web scraping agents that survive site redesigns
- AI engineers wiring browser control into an existing agent framework
- QA teams automating end-to-end tests on dynamic pages
- Teams replacing Playwright or Selenium selector maintenance with self-healing actions
- Non-technical users looking for no-code or point-and-click automation
- Teams that want a fully managed black-box agent with no code to own
- Mobile browser automation — the SDK targets desktop Chromium
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Stagehand if you want a no-code recorder or a fully managed black-box agent and don't want to own browser setup, retries, and scaling in your own codebase.
Running the AI primitives (act, extract, observe, agent) spends model tokens on every call, so a large crawl's inference bill can exceed your compute bill — the 7.4k-token extract() benchmark is per page read, not per
Stagehand itself is an open-source SDK you can run locally for free, so the real budget question is inference and browser infrastructure rather than a seat license. That makes it cheaper than per-seat no-code automation platforms for small engineering teams, and comparable to writing raw Playwright yourself once you factor in the token spend on act() and extract() calls. Large crawl volumes shift the cost curve toward model inference and managed browser hosting.
In short
Stagehand — Open-source SDK for building browser agents with AI primitives (Act, Extract, Observe, Agent) plus Playwright-style controls in TypeScript, Python, and Go. Best for Developers building web scraping agents that survive site redesigns, AI engineers wiring browser control into an existing agent framework, QA teams automating end-to-end tests on dynamic pages. Free to use.
What's new in Stagehand
Checked 4 days agoAcross the latest 2 updates: 2 news mentions.
Why Playwright MCP Uses So Many Tokens (and How to Fix Context Loss)
The Stagehand team benchmarks Playwright MCP accessibility snapshots to show where tokens accumulate in context across turns, and how Stagehand's hybrid accessibility tree trimming compares.
What is Stagehand?
An introduction to the open-source browser agent SDK covering how browser control methods work alongside the AI primitives.
What people actually say about Stagehand — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
57 mentions across 3 sources (Hacker News, App Store, Lemmy) · researched Jul 3, 2026.
Average across the 3 sources that answered — each source counts once, not each post.
- +Natural language instructions survive DOM changes without maintenance.
- +Open-source Apache 2.0 — no vendor lock-in for local use.
- +Incremental adoption: replace flaky selectors in existing Playwright code.
- +Zod schema validation for structured data extraction (extract()).
- +Optional Browserbase cloud for captcha solving and session replay.
- −AI can misinterpret instructions, causing runtime non-determinism.
- −Token costs add up quickly on longer multi-step workflows.
- −Community feedback is sparse — hard to validate reliability at scale.
- −No native support for Firefox or Safari browsers.
- −Competitor Sentinel claims 3x fewer tokens for similar tasks.
- • Token costs for LLM API calls when using AI resolution (not baked into SDK)
- • Browserbase cloud services have separate pricing not detailed in community data
Viability Score
How well maintained and how widely used is Stagehand? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Act(): execute browser actions from natural-language prompts
- Extract(): pull structured data validated against Zod schemas
- Observe(): discover available actions on any page before committing
- Agent(): run multi-step browser workflows autonomously
- Playwright-style API: goto(), click(), type(), locator(), keyPress(), screenshot()
- TypeScript, Python, and Go SDKs with matching methods and options
- Self-healing actions that re-resolve when site markup changes
- Runs as a browser extension next to the page to cut round-trip latency
- Hybrid accessibility tree trimming for token-efficient page context (7.4k vs 35.7k tokens benchmarked)
- Built-in caching to skip repeated operations (v4)
- Network-level domain allowlist and blocklist for prompt-injection risk (v4)
- WebMCP support for agent interoperability
- Clipboard support and batched commands
- Deep locators for nested iframes and closed Shadow DOMs
- Built-in OTel tracing plus per-method metrics() for token usage and inference timing
About Stagehand
Stagehand is an open-source SDK for developers building browser agents that need precise control over real web pages. Where Playwright was designed for testing, Stagehand was designed for agents: it keeps the familiar goto(), click(), locator(), keyPress() and screenshot() methods, and layers on AI primitives — act() for natural-language actions, extract() for schema-validated structured data through Zod, observe() to discover actionable elements, and agent() for autonomous multi-step workflows. The SDK ships across TypeScript, Python, and Go with matching method names and options. The architectural difference is where the runtime lives. Stagehand runs as an extension next to the browser rather than driving it remotely, which closes the distance and cuts round-trip latency — the vendor benchmarks a batch click-and-type task at 4.7s against Playwright's 9.0s. Hybrid accessibility tree trimming keeps the page context handed to the model lean; the same benchmark shows 7.4k tokens for extract() versus 35.7k with Playwright. Native handling of out-of-process iframes and closed Shadow DOMs covers DOM structures raw Playwright doesn't touch, and self-healing selectors re-resolve when a site ships a redesign. The project reports 23.7k GitHub stars. Stagehand v4.0.0 adds built-in caching to skip repeated operations and network-level security — domain allowlist and blocklist — aimed at prompt-injection risk in agent browsing. You also get WebMCP support, clipboard access, batched commands, deep locators for nested iframes, and built-in OTel tracing plus per-method metrics() for token usage and inference timing. Models are flexible: name a supported provider or supply your own client-side LLM callback. This is infrastructure for engineers, not a no-code automation builder. It's the hands; you bring the agent as the brain, wiring in LangChain, CrewAI, Mastra, or a custom loop. Teams that want to hand a browser to an LLM agent and keep determinism, tracing, and version control over the actions will get the most from it. Teams that want a point-and-click recorder should look elsewhere.
Behind the Verdict
Stagehand's pitch is a positioning argument as much as a technical one: Playwright was built for testing, Stagehand is built for agents. The technical substance behind that claim is real in three places. First, the runtime. Stagehand runs as an extension next to the page over the Chrome DevTools Protocol rather than driving a remote browser, and the vendor's benchmark puts a batch click-and-type task at 4.7 seconds versus 9.0 seconds for Playwright. Second, context discipline. Hybrid accessibility tree trimming produces 7.4k tokens for a representative extract() call where the Playwright path consumes 35.7k — that is roughly 80% fewer tokens per page read, which is the difference between an agent loop that is affordable at volume and one that isn't. Third, DOM coverage. Out-of-process iframes, closed Shadow DOMs, and deep locators for nested iframes are handled natively, and self-healing actions re-resolve when markup changes instead of throwing a selector error at 3am. The v4.0.0 release is the most interesting piece for production teams. Built-in caching skips repeated operations, which compounds with the token savings. Network-level domain allowlist and blocklist is a security control, not a feature bullet — if your agent browses untrusted pages, prompt injection is the threat that actually bites, and gating egress at the network layer is a defensible answer. WebMCP support, clipboard access, batched commands, and built-in OTel tracing with per-method metrics() round out the observability story that most AI browser tools skip entirely. The honest constraints are structural. This is an SDK, not a product: there is no visual recorder, no hosted dashboard, and no support contract implied by a repo. You supply the agent loop — Stagehand positions itself as the hands while you bring the brain via LangChain, CrewAI, Mastra, or your own orchestration. It targets desktop Chromium (Chrome, Edge, Arc, Brave), so mobile browser automation isn't in scope. Scaling past a local Chromium instance is your problem or Browserbase's, depending on the path you pick. And if your scraping job is a static page that requests handles fine, adding an agent layer is overhead. Where it fits: teams replacing selector maintenance in Playwright or Selenium with self-healing primitives; AI engineers wiring browser control into an existing agent framework; QA groups running end-to-end tests on dynamic pages; anyone scraping frequently-changing sites without public APIs who needs typed, schema-validated output rather than parsing HTML by hand. Where it doesn't: non-technical users, teams who want a managed black-box agent with no code to own, and anyone unwilling to own browser lifecycle and retry logic.
Researching Stagehand? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Stagehand actually fits — and what changes day-one when you adopt it.
Install @browserbasehq/stagehand, launch a local Chromium, and migrate existing goto()/click()/locator() calls unchanged, then swap the selector-fragile steps for act() and extract() with a Zod schema so the output is typed.
Outcome: Scraping jobs keep running through site redesigns instead of failing on renamed classes, and extracted records arrive schema-validated rather than parsed by hand.
Wire Stagehand in as the browser tool, keep the agent framework as the reasoning loop, and use observe() to discover available actions on unfamiliar pages before committing to act() calls.
Outcome: The agent navigates real sites with deterministic fallbacks when needed, and metrics() exposes per-method token usage so the loop can be tuned for cost.
Run the suite through Stagehand's Playwright-style page methods for known flows, and fall back to self-healing act() steps for the screens that get restyled every sprint.
Outcome: Fewer test failures caused purely by selector drift, with OTel tracing available when a run does break.
Use Cases
- Extract product prices and details from e-commerce sites that change layout often
- Automate login, navigation, and data extraction from internal dashboards
- Run end-to-end tests that adapt to UI updates without rewriting selectors
- Build a browser agent that fills forms and completes multi-step workflows
- Scrape sites without public APIs where markup shifts frequently
- Add typed, schema-validated web data extraction to an existing agent framework like LangChain or CrewAI
- Instrument browser agent runs with OTel tracing and per-method token metrics
Models Under the Hood
as of 2026-09-25
Limitations
- Stagehand is an open-source SDK, so you own the agent loop, browser lifecycle, retries, and scaling — there is no visual recorder or no-code surface.
- It targets desktop Chromium browsers (Chrome, Edge, Arc, Brave) and drives them over the Chrome DevTools Protocol, so mobile browser automation is out of scope.
- Scaling beyond a local Chromium instance means running it yourself or deploying through Browserbase.
- The scraped and seed sources name no specific underlying LLM models, so model support cannot be verified from the available data; the docs only say you can use a supported provider by name or supply your own client-side LLM callback.
- If your job is simple static scraping, raw Playwright or an HTTP client is lighter weight than adding an agent layer.
as of 2026-10-04
Verification history
We have re-verified Stagehand 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
Showing the 6 most recent of 9 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Stagehand tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Local
$0/mo
Ideal for
Developers and AI engineers running browser agents on their own machine with a local Chromium install and their own model credentials.
What this tier adds
Starting tier — the open-source SDK itself, free to run locally with TypeScript, Python, and Go, the Act/Extract/Observe/Agent primitives, self-healing actions, v4 caching, and domain allowlist/blocklist.
Cloud (Browserbase)
Usage-based
Ideal for
Teams that have outgrown a single local Chromium instance and need browser agents running in production at scale.
What this tier adds
Adds managed browser infrastructure and production deployment on top of the same Stagehand SDK surface, billed on usage.
Where the pricing makes sense
The company stage and team size where Stagehand's pricing actually pencils out — and where peers do it cheaper.
Stagehand itself is an open-source SDK you can run locally for free, so the real budget question is inference and browser infrastructure rather than a seat license. That makes it cheaper than per-seat no-code automation platforms for small engineering teams, and comparable to writing raw Playwright yourself once you factor in the token spend on act() and extract() calls. Large crawl volumes shift the cost curve toward model inference and managed browser hosting.
Setup time & first value
How long it actually takes to get something useful out of Stagehand — broken out by persona, not the marketing-page minute.
Developers with npm and a Chromium install reach a first extract() call in well under an hour following the quickstart. Wiring Stagehand into an existing agent framework like LangChain or CrewAI takes an afternoon. Migrating a mature Playwright suite is the long pole — the v3-to-v4 and Playwright-to-v4 migration guides in the docs scope it, but expect a multi-day pass for large suites.
Switching to or from Stagehand
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From Playwright: keep goto(), click(), locator() and screenshot() unchanged, then replace brittle selectors with act() and extract() where sites change often — the docs publish a Migrate Playwright to v4 guide.
- →From Stagehand v3: the docs ship a Migrate v3 to v4 guide covering the API changes between versions.
- →From Puppeteer: Stagehand drives Chromium over the Chrome DevTools Protocol with no Playwright or Puppeteer dependency, so scripts port without carrying the old framework along.
- →From hand-rolled Selenium scraping: swap selector maintenance for self-healing actions and schema-validated extract().
- ↗To raw Playwright: if your pages are stable and you no longer need act()/observe(), the Playwright-style API you already use carries over directly.
- ↗To a no-code automation platform: if the team owning the automation isn't writing TypeScript, Python, or Go, Stagehand is the wrong layer and a point-and-click tool fits better.
- ↗To a managed agent product: if you don't want to own browser setup, retries, and scaling, a hosted black-box agent removes that work at the cost of control.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Stagehand”, and we withheld 6: 6 could not be judged, because “Stagehand” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Stagehand.
Official links
Tools that pair well with Stagehand
Common stack mates teams adopt alongside Stagehand, with the specific reason each pairing earns its keep.
Chrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools access for debugging, automation, and performance traces.
Open Interpreter
Open Interpreter is an open-source terminal agent that turns plain-English requests into real file edits and shell commands on your machine.
OpenAgents
OpenAgents is an Apache-2.0 platform for language agents that analyze data, call 200+ plugins and browse the web.
Featured Head-to-Head Comparisons
Stagehand vs Locus Robotics
For warehouse operators needing physical automation, Locus Robotics delivers proven 2-3x productivity gains with its AMR fleet and RaaS model. For developers building browser agents, Stagehand offers a free, open-source SDK that makes automation resilient to DOM changes. Choose based on your domain: logistics vs. software.
Stagehand vs Truleo
Truleo and Stagehand solve fundamentally different problems. Truleo is a specialized, paid intelligence platform for law enforcement to connect siloed data and generate leads, while Stagehand is a free, open-source developer SDK for building resilient browser automations. Choose based on your domain: if you're a police department needing case leads, choose Truleo; if you're a developer automating web interactions, Stagehand is the clear and cost-effective winner.
Stagehand vs Presto Voice
Presto Voice and Stagehand serve entirely different markets. Presto Voice is a specialized drive-thru voice AI solution for QSR chains, validated by major deployments like Dairy Queen (2026), whereas Stagehand is a developer-focused open-source SDK for browser automation. Choose Presto Voice if you run a drive-thru chain wanting revenue lift; choose Stagehand if you need AI-resilient web scraping or testing. They are not direct competitors; the decision hinges on whether your problem is physical drive-thru operations or digital browser automation.
Alternatives to Stagehand
View allChrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools access for debugging, automation, and performance traces.
Open Interpreter
Open Interpreter is an open-source terminal agent that turns plain-English requests into real file edits and shell commands on your machine.
OpenAgents
OpenAgents is an Apache-2.0 platform for language agents that analyze data, call 200+ plugins and browse the web.
Frequently Asked Questions
Best-of guides
Used Stagehand? Help shape our editorial sentiment research.