Read more about Browserbase - a web browser for your AI - the company, product, features, and news on the Browserbase blog

Browserbase Blog: Automate the web

The Browser Blog

Paul Klein

Web agents are a core primitive for new AI-powered applications.

An Internet Browser for AI

Jason Howmans

We're so excited to finally migrate all of our accounts to our new Organization structure. If you signed up for Browserbase on or after May 4th, 2025 - you're already in the new setup! Here's documentation on how concurrency will work.

Starting June 4th, 2025, Browserbase will move all remaining customers from single user accounts to multi-user and multi-project supported Organizations.

This means your team can have their own logins, see sessions across shared projects, and manage multiple projects under one org. Or if you're building alone, you can have multiple projects within your account.

**There is no action required on your part!**

On June 4th, 2025, we will automatically do the following:

*   Convert your current Browserbase account to an Organization. You will be prompted to add an organization name & slug upon login.
    
*   Your API key will stay the same, and all of your historical session data, billing information, and usage will remain in your project.
    
*   If you have additional emails associated with your account, they will be automatically added as additional members to your new Organization and prompted to create a password upon login.
    
*   There is no limit to the number of members you can add!
    

Your account is scheduled to **migrate on Wednesday, June 4th, 2025 and there will be zero downtime** during the migration.

Thank you for your cooperation, we’re excited to see how you take full advantage of the new orgs setup! Can’t wait to see what you build with it.

If you have any questions or concerns, reply or contact us at support@browserbase.com.

Happy building! 🅱️

Starting June 4th, 2025, Browserbase will move from single user accounts to multi-user and multi-project supported Organizations.

Organizations are coming June 4th

Anirudh Kamath

Sean McGuire 

## Quantify the vibes with Stagehand: How good are LLMs at analyzing deeply nested, structured data?

### Evaluating agents is still an unsolved problem.

Agents are designed to perform tasks, but assessing their performance involves many factors: did it do the right thing? How many "right" ways are there to do it? How many steps did it take? What kinds of tasks does it do well? What kinds of tasks does it do poorly?

Instead of trying to evaluate every aspect of an AI agent, we can focus on a simpler question: "Given a specific instruction like "click the button", was the expected button clicked?"

This approach allows for more straightforward and rigorous evaluations. By concentrating on whether the AI can accurately translate a specific instruction into a precise action using tools like Playwright, we can better understand an LLM’s capabilities.

![](https://framerusercontent.com/images/KfGjEhxOr88NrsIWikPFumH8Ss.gif)

### Stagehand: Break down agents into precise, natural language instructions

Stagehand (stagehand.dev) exposes “tools” for LLMs to control a browser, bridging the gap between fully agentic workflows and fully hardcoded Selenium/Playwright/Puppeteer. These tools are the following:

*   **Act**: execute actions on a webpage with natural language using `act("click the button")`
    
*   **Observe**: preview actions before they are executed with `observe("click the button")` so you can cache actions or provide context to a higher level agent
    
*   **Extract**: extract structured data from webpages with `extract("the top news story")`
    

By converting natural language instructions into precise web actions, Stagehand enables developers to describe a specific, precise action without having to worry about the tedium of writing cumbersome Selenium, Puppeteer, or Playwright code.

Stagehand composes a custom data structure that leverages the strengths of both the DOM and Accessibility (a11y) Tree to send to an LLM (example). The expected LLM output is a specific Playwright action that can be executed or cached for future usage. In doing so, the LLM can parse the entire website as text without the clutter of the raw DOM.

For example, `act("click the jobs link")` will analyze the DOM and a11y tree and output something like this:

```javascript
/** A JSON-serialized output of act("click the jobs link"): */
{
  description: "The jobs link",
  action: "click",
  selector: "/html/body/div[1]/div[1]/a",
  arguments: []
}
```

For the times you want to write actual code yourself instead of relying on AI, Stagehand has full compatibility with Playwright, allowing you to have as fine-grained control as you want.

### What makes Stagehand evaluations rigorous?

We have a set of evals that we use to test against regressions in our PRs. These evals are simple — take an action with Stagehand, and then check if the output (Playwright action or text) matches the expected output. We run the following sets of evals:

*   **Act**: Go to a page, run an action like `"click the login button"`, and verify the resulting page URL contains `/login`.
    
*   **Extract**: Go to a page, extract data like `"the top news story"`, and then check if the extracted data matches the expected output.
    
*   **Observe**: Go to a page, plan an action like `"click the login button"`, and then check if the action preview has the intended interaction and DOM selector.
    
*   **Combination**: Chain `act()`, `observe()`, and `extract()` together to test the models' ability to handle more real-world tasks.
    

We have ~10 tests per category, and we run each eval 3 times per model to account for any website volatility. Many websites are cloned via Surge and hosted on GitHub Pages to remove website volatility and antibots where possible.

We tracked exact match rate, speed, cost, and error rates to provide a comprehensive evaluation of each model's performance.

## The results: Gemini takes the crown, and it’s not close

### Which models are the most accurate?

![](https://framerusercontent.com/images/QiX6l7imu36wDeTuiA7YyrZ84g.png)

**Gemini 2.0 Flash takes the crown as the most "accurate" model** — some other interesting takeaways:

*   Llama 4 had pretty disappointing results, even with their Maverick model, which was supposed to be on par with the other frontier, flagship models
    
*   Claude 3.7 Sonnet performed _worse_ than its predecessor 3.5, and even worse was that GPT-4.5 was _**atrocious**_.
    
*   Gemini 2.0 Flash-lite has surprisingly good performance for such a small model — it's half the price of Gemini 2.0 Flash, which is already ridiculously cheap
    

### Does a price premium equate to better performance?

![](https://framerusercontent.com/images/rpHgeZxc60DmtiOuW8YRKdA4e0s.png)

Adding price adds a whole new dimension — Gemini 2.0 Flash, the most accurate model, came in at about $.002/task — you could run each set FIVE TIMES for ONE CENT. The next best model, GPT-4o, offers slightly worse performance for 20x the cost, and that's still cheaper than Claude!

GPT-4.5 is, again, horrendously expensive and inaccurate.

## What about how fast the models are?

We measured average LLM inference time per task, and once again, Gemini is ridiculously good.

![](https://framerusercontent.com/images/G6KxxHKc5oCJadLxbugyiWG34.png)

Groq's hosted Lllama 3 70B model takes the cake for the fastest model, but it's far from the most accurate. Gemini is again among the cheapest and most accurate models, and it's also top 5 in latency, ahead of its frontier counterparts by OpenAI and Anthropic.

Overall, Gemini 2.0 Flash is the most accurate model AND among the fastest and cheapest.

## Break down by act, extract, and observe (full Analysis on Hex)

We made these charts on Hex, and the full analysis can be found here, including links to Braintrust runs with chat traces per eval.

![](https://framerusercontent.com/images/m2iEhPaQdlcbGk4JWznqJTldw.png)

![](https://framerusercontent.com/images/FTZbA144znXTcHqPLjRvizU5og.png)

![](https://framerusercontent.com/images/LL91snkOQHqxWoIYJC9PpXQoE.png)

### Conclusion

*   Gemini is unreasonably good — the cheapest AND most accurate, and among the fastest models on the market.
    
*   GPT-4o and Claude 3.5 Sonnet were pretty good, but not worth the 20-30x price premium over Gemini.
    
*   Newer models like Claude 3.7 Sonnet and especially GPT-4.5 seem more “creative” and not ideal for doing _exactly_ what you want to do.
    
*   **Get Started with Stagehand**: We've open-sourced Stagehand to help you get started with AI-powered web automation. Get started with Stagehand at stagehand.dev.

Instead of trying to evaluate every aspect of an AI agent, we can focus on a simpler question: "Given a specific instruction like "click the button", was the expected button clicked?"

Unit-testing AI Agents in the Browser

Ash Rathie

In a landscape where conventional automation tools are painfully brittle and fully agentic solutions can be too unpredictable, Stagehand emerges as the best AI-powered browser automation framework available today. By combining atomic instructions with the flexibility of a dynamic agent, **Stagehand delivers a complete and robust framework for any Web AI Agent workflow.**

Read time: 5 minutes

## TL;DR

*   **Stagehand** is an AI web agent framework that bridges the gap between brittle traditional automation (e.g., Playwright, Puppeteer, Selenium) and unpredictable full-agent solutions (e.g., OpenAI Operator).
    
*   It uses **atomic primitives** (act, extract, observe) for precise control and a **dynamic Stagehand Agent** for high-level decision making.
    
*   Key innovations include cleaner data extraction via the **Chrome Accessibility Tree**, optimized **LLM selection**, and **better self-healing**.
    
*   The integration of the **Model Context Protocol (MCP)** brings Stagehand to any external LLM—combining Stagehand with Claude delivers an OpenAI Operator alternative that’s more controlled and reliable.
  
	



## The Stagehand Philosophy: Control and Flexibility

Let’s be honest: traditional browser automation frameworks such as Playwright, Puppeteer, or Selenium are fantastic for executing explicit commands—click this here, type that there—but they crumble when a website changes just slightly. A tiny UI tweak can break an entire script, leaving you scrambling to fix brittle code. On the other end of the spectrum, full agent-based solutions like OpenAI Operator or Anthropic Computer Use promise full automation from just a prompt. You simply instruct the agent in natural language, and it takes over. However, that level of abstraction often comes at the cost of control—developers can end up with unpredictable outcomes.

Stagehand was born out of the need for a middle ground. Instead of forcing you to choose between writing fragile code or handing everything over to an opaque agent, Stagehand gives you the best of both worlds:

**Atomic Instructions:** The framework provides three key primitives—**act(), extract(), and observe()**—that let you define precise, one-to-one browser interactions. Think of these as the building blocks of reliable automation: you tell Stagehand to "click this button" or "type this text," and it maps that command directly to a browser action. In the new Stagehand, act() no longer recursively loops. Complex, multi-step actions are now handled by agent().

```javascript
await page.act("click on the contributors selection");

const { title } = await page.extract({
  instruction: "the top contributor's username",
  schema: z.object({
    title: z.string(),
  }),
});
```

**Dynamic** **Agent**: For those tasks that require higher-level decision making, Stagehand introduces the Stagehand agent(). This component breaks down even complex workflows into a sequence of browser commands. It allows you to delegate high-level instructions—like “retrieve the top 5 contributors to the stagehand repo”—while still maintaining granular control over how each step is executed. agent() caches the preview steps it took, reducing LLMs calls and optimizing performance. It makes new calls when the cached actions fail.

```const agent = stagehand.agent();

const {message,actions} = await.execute(

"Extract the top contributor's username"

)
```


### A High-Level Use Case Comparison

Imagine you need to automate the process of filling out a web form and then extracting specific lead data:

1.  **Using Playwright (Traditional Automation):** You’d write explicit code to navigate to the form, identify each field, input data, and submit the form. While this offers precision, if the website’s structure changes even slightly (say, the form’s layout is updated), your code might break, leaving you with brittle automation.
    
2.  **Using a Fully Agent-Based Product (OpenAI Operator):** You’d simply instruct the agent in natural language: “Fill out this form and extract the lead information.” The agent would decide the best approach, but you’d lose control over which elements are interacted with and how. The process might work in some cases but could lead to unpredictable outcomes if the agent’s reasoning isn’t aligned with the desired precision.
    
3.  **Using** **Stagehand**: You can combine the strengths of both approaches. With Stagehand, you can use act, extract, and observe to issue precise commands (e.g., “click the submit button,” “extract the email field”) while also employing the Stagehand Agent for high-level orchestration when necessary. This gives you an automation script that’s both resilient to UI changes and flexible enough to handle complex decision-making processes.
    

### Real World Applications

Stagehand’s flexibility makes it an ideal choice for developers seeking reliable AI-powered browser automation. Here are a few examples of how developers are using Stagehand:

*   **Automated Form Filling & Lead Enrichment:** Consider a scenario where you need to extract lead information from hundreds of company websites. With traditional tools, you’d write and maintain brittle scripts that could break at the slightest UI change. A full agent solution might not provide the control you need to ensure accurate data capture. Stagehand, however, empowers you to design an automation pipeline that fills out forms with atomic precision and then dynamically enriches data using high-level reasoning—all while adapting to slight changes in the website’s layout.
    
*   **Intelligent Document Editing:** Product managers and developers often need to compare documentation versions or even auto-generate code samples based on changes. The Stagehand Agent can review the documentation, compare it with a changelog, and suggest improvements all in one fell swoop. This hybrid approach makes the process more efficient and reliable compared to conventional manual editing or a fully automated agent that lacks context.
    
*   **Robust Web Crawling for Data Extraction**: In applications where continuous, reliable data extraction is critical—such as monitoring pricing, gathering competitor intelligence, or even parsing news sites—Stagehand shines. By blending atomic commands with high-level agentic decisions, it enables your script to carry out tasks reliably and resiliently.
    

  
	

### What We Learned While Building Stagehand

The evolution to this new version of Stagehand has been a journey of discovery and refinement. Here are some of the key lessons the team learned along the way:

*   **From Raw DOM to the Chrome Accessibility Tree:** Initially, our approach relied on parsing the raw DOM of web pages. However, we soon discovered that the Chrome Accessibility Tree offers a much cleaner, more reliable view of a webpage by filtering out unnecessary noise. This shift not only improved the accuracy of actions but also increased the overall resilience of our automation scripts. Previously an optional flag, this is now the default behavior in the new version of Stagehand.
    
*   **Understanding LLM Behavior:** In building Stagehand, we tested various large language models (LLMs) and found that they each have their unique strengths. For instance, Claude excels in high-level reasoning, making it ideal for dynamic decisions, whereas GPT-4o and GPT-4o mini are better suited for executing specific browser actions. Conversely, Gemini struggled with structured outputs, but is really good at observe(). These insights allowed us to fine-tune our integrations, ensuring that Stagehand delivers the highest-quality overall performance.
    
*   **Implementing Multidimensional Self-Healing**: A major challenge was building highly resilient self-healing by understanding intent rather than just actions. If a single element changes, your script might fail. If you've built in some level of self-healing, then perhaps your script can re-examine the page to find a viable alternative. But what happens if a button disappears altogether? There is no clear alternative to “click the Pricing button”. Stagehand's multidimensional self-healing option allows you to fall back to a full agent that reviews what has happened and reassess the overall goal. The agent then decides how to complete the task using the current context. The end result is minimized downtime as your automation keeps running smoothly even when unexpected changes occur.
    

![](https://framerusercontent.com/images/DxkJfgkWBXIKVQCwTBM3mjy9Fk.png)



### MCP Integration

In addition to its core framework (act(), extract(), observe(), and agent()), the capabilities of Stagehand can also be leveraged through MCP (Model Context Protocol). Particularly effective with Claude, the Stagehand MCP enables external agentic AI to perform browser actions better than any alternative—effectively emulating OpenAI Operator, but with far greater control and reliability. In practice, this means that when you instruct an agent with access to Stagehand MCP, it translates natural language prompts into a structured, reproducible sequence of browser operations. See it in action or experience it yourself. Browserbase has been a pioneer in the open source MCP community (we first released our MCP server in November 2024).

![Stagehand MCP (Model Context Protocol) being used by Claude to perform automated browser actions. The web AI agent is navigating to OpenAI's website. ](https://framerusercontent.com/images/7k2A82QeOUdbOB0yNP1vLH2Ba0.png)

### Open Source, Developer Support & Community

![Image showing the banner of Stagehand GitHub repo. Stagehand is an AI web agent SDK that is open source. It has 9.3k stars on GitHub. ](https://framerusercontent.com/images/bAviGPxjGjRyI73m8fRNOKPZ4rA.png)

Trust and transparency are critical as we create new AI capabilities. We believe the best way to achieve that is through open source. A vibrant community of developers continue to contribute, refine, and build upon Stagehand, making it even more innovative and high-quality. Comprehensive documentation, active support from the team (reach out to Ani at anirudh@browserbase.com), and regular community feedback ensure that Stagehand remains a reliable and cutting-edge solution.

This open source model has proven invaluable. It allows developers to understand exactly how the automation works, customize it to their needs, and even suggest improvements that can be quickly integrated. The result is a robust ecosystem where trust and collaboration drive continuous innovation—exactly what you’d want from an AI web agent framework.

### Stagehand, Now and in the Future

Where is the world of AI web agents headed? The conversation is evolving, and the future holds both great opportunities and tough challenges. How we use AI web agents today is not how we will use them in five years.

Imagine a future where an ecosystem of mini-agents emerges—each one specialized in its own domain yet working together on complex tasks. In this vision, the main agent could delegate specific jobs to sub-agents that handle form filling, image recognition, data extraction, and more. This microservice-like approach is an evolution we are already beginning to see, especially as MCP gains momentum.

Alternatively, we might reach a point where a single, highly agentic AI performs all actions without assistance. Whatever the future may bring, we at Browserbase are always thinking about how the space is evolving. Today, developers need both control over the workflow and relief from the tedious details, and that’s the balance we wanted to strike with Stagehand 2.0. As this balance shifts, Stagehand will evolve with it.

<custom-cta text="Try Stagehand for your web agent" button_text="Github" button_link="https://github.com/browserbase/stagehand"></custom-cta>

In a landscape where conventional automation tools are painfully brittle and fully agentic solutions can be too unpredictable, Stagehand emerges as the best AI-powered browser automation framework available today. By combining atomic instructions with the flexibility of a dynamic agent, Stagehand delivers a complete and robust framework for any Web AI Agent workflow.

Stagehand gets even better – The AI Web Agent SDK

Today, Browserbase has been named to the seventh annual Enterprise Tech 30—a definitive list of the most promising, private enterprise tech companies across all stages of maturity.

We're honored to be part of such a powerful list of companies. It's such an exciting time to be building an AI infrastructure company!

#### Browserbase's place in the AI landscape

AI isn’t just flying, it’s traveling at warp speed. Along with AI’s momentum comes an imminent need for reliable railroad tracks for the first trains traversing this new landscape. Developers are using LLMs to automate more tasks than ever before and web browsers are an essential platform to execute these automations… and developers need help running them, which is where Browserbase comes in.

Developers use headless web browsers to programmatically interact with the web. These headless web browsers are especially difficult to run in a production environment. With Browserbase, customers simply connect to a managed web browser that integrates seamlessly with their existing code.

Browserbase is excited about continuing to power the world's best AI tools.

#### What's next?

Hiring! In the age of AI, talent is the biggest differentiator. Our team is the reason that Browserbase is being named the #1 early-stage startup today by ET30. They're some of the most impressive and fun people I've ever worked with.

Join us! https://browserbase.com/careers

#### The selection process

The Enterprise Tech 30 reveals the enterprise startups who have the most potential to meaningfully shift how enterprises operate. Companies are inducted into the community through a selection-only process based on a successful background and substantial reach in enterprise technology. Nearly 600 venture-backed private enterprise tech companies across various stages were considered in the two-phase process by a record 100+ venture capitalists.

For more information on the research methodology, additional insights, and to view the results, visit enterprisetech30.com.




Today, Browserbase has been named to the seventh annual Enterprise Tech 30—a definitive list of the most promising, private enterprise tech companies across all stages of maturity. We're honored to be number one on the early companies list. 

Browserbase named #1 on the Enterprise Tech 30 list

### What is a headless browser?

The innate value of code is its ability to automate work on behalf of people. Traditionally, that means connecting many APIs together, processing data, and presenting it in a beautiful interface. Code uses other code to get things done.

Over the last decade, software has undergone a massive shift from desktop to web applications. People now complete their work, handle their finances, and run their businesses through web browsers. As more of our daily tasks move online, the desire to automate web-based workflows becomes increasingly crucial. But what if you want to automate something that doesn't expose an API? What if you need to interact with an application that hasn't been built to be used by code?

Simply fetching HTML data from the website often isn't enough. Modern websites use JavaScript to load data on the client side and control interactive elements - if you only retrieve the HTML, you miss crucial parts of how the application actually works.

Instead, what if you could use software the same way people do? Going to the website, clicking buttons, submitting forms, and performing all the actions a person would do. But instead of being controlled by a human, it's controlled by code.

This is the concept of a headless browser.

## How does a headless browser work?

A headless browser is a browser designed to be controlled by code. It's functionally identical to the web browser you use on your machine, but can run on a server. It's "headless" because there's no graphical user interface (GUI), but it still loads and interacts with pages exactly like a regular web browser does.

But if there's no GUI, how does code control a headless browser? The answer lies in browser protocols - standardized ways for code to communicate with and control browsers. The most widely used is the Chrome DevTools Protocol (CDP), which provides low-level control over browser operations.

These protocols are low-level, meaning they provide a lot of control over the browser, but they are also complex and difficult to work with. It's like building software using machine code.

That's why developers typically use browser automation frameworks - tools that provide simple, abstracted interfaces for controlling browsers.

## Browser automation frameworks

Browser automation frameworks make it easy to write code that controls browsers. They handle the complexity of protocol communication and provide familiar programming interfaces. Here are the most popular options:

#### Playwright

*   Created by Microsoft
    
*   Modern, promise-based API
    
*   Originally focused on testing web applications

<br>

#### Stagehand

*   Created by Browserbase
    
*   A superset of Playwright, with AI features for self-healing automations
    
*   Specialized for browser automation
    

#### Puppeteer

*   Developed by Google’s Chrome team
    
*   Deep integration with CDP
    
*   Excellent for PDF generation and screenshots
    

#### Selenium

*   Oldest automation framework
    
*   Uses WebDriver protocol - a legacy protocol for browser automation
    
*   Large ecosystem of tools and plugins
    

## Using headless browsers

Headless browsers unlock new possibilities for developers. By enabling code to interact with any website the same way people do, they allow you to build integrations without being limited by available APIs.

Getting started with headless browsers is straightforward. With just a few lines of code, you can automate basic web interactions locally:

```
const { chromium } = require('playwright');

async function example() {

const browser = await chromium.launch();

const page = await browser.newPage();

await page.goto('https://example.com');

await page.click('#submit-button');

}
```

However, running headless browsers in production presents significant challenges.

You need to:

*   Manage browser instances and resources
    
*   Handle concurrent sessions
    
*   Deal with browser crashes and cleanup
    
*   Scale infrastructure as demand grows
    
*   Monitor performance and reliability
    

This is where Browserbase comes in. We provide a reliable, scalable infrastructure for running headless browsers in production, letting you focus on building your automation logic rather than managing browser infrastructure.


A headless browser is a web browser controlled by code that uses software like humans do - visiting sites, clicking buttons, and submitting forms, all automatically.

What is a headless browser?

Beatriz Go

We finally did it!
------------------

Today, we're thrilled to announce what many of you have been asking for – a free plan at Browserbase. We've designed our free plan to give you a better experience with our platform, more time to understand our value proposition, and a place for your personal projects.

What's changing?
----------------

Our previous sign up experience included 10 total web browser sessions to test our product. While this was a starting point, we've heard from many of you that it didn't provide enough opportunity to properly evaluate Browserbase and understand how it could fit into your workflows.

**Starting February 25, 2025, our new free plan includes:**

*   **60 minutes of browser sessions per month** recurring monthly from your sign-up date
    
*   **15-minute maximum session duration** to help you manage your time efficiently
    
*   **7-day data retention** for all your sessions
    
*   **The same reliable browser automation you expect from Browserbase**
    

![](https://framerusercontent.com/images/l3zonw4Qf4hU1aHJ8gNBpgOavqA.png)

Why we’re launching this now
----------------------------

For those familiar with browser automations, we want you to have a chance to explore and test the exciting features we’ve recently rolled out. It should be easy to get started and seamless to grow with us when it’s time.

For those less familiar with browser automations, we want to make them more accessible! Build your first automation, test out Stagehand, or experiment with new ideas, on us.

We also just think Browserbase is really cool, and we want you to experience this for yourself. The free plan is your chance to explore.

Your personal app awaits
------------------------

It’s important to us that the free plan is generous enough to power your personal projects, while also balancing the real cost of providing the browser infrastructure behind it. We built a script that looks up a recipe and orders the ingredients, and it only takes about 10 browser minutes. That means you could run this 6 times per month!

Now you can build that restaurant reservation bot or automate your grocery delivery, for free.

Ready to get started?
---------------------

If you've been browser-curious but haven't yet tried our product, now is absolutely the time to jump in! The playground is open, and we can't wait to see what you'll build.

We finally did it! Today, we're thrilled to announce what many of you have been asking for – a free plan at Browserbase.

The Browserbase Free Plan (Finally!)

Alex Phan

In web automation and testing, three tools tend to lead the field: Playwright, Puppeteer, and Selenium. Each tool has its own features and benefits.

However, for the most powerful and reliable option, Playwright is the best of the three. At Browserbase, we support all three frameworks. We have seen why developers and teams often choose Playwright for modern automation. In this article, we will break down the key differences and explain why Playwright reigns supreme.

We'll also check out Browserbase's new open-source library called Stagehand: the robust, AI-powered successor to Playwright.

## Choosing Your Browser Automation Tool

### What to Look for in 2025

Before finding out what tools are out in the market, it’s important to know what to look for. Some of these features that developers often as for are listed below:

*   Setup and initialization process is streamlined, requiring minimal configuration compared to other frameworks.
    
*   Chrome execution is highly reliable due to direct integration with Chrome DevTools Protocol.
    
*   The framework provides debugging capabilities through modern tools.
    
*   Documentation is comprehensive, with guides, API references, and practical examples that help developers get started quickly.
    

## Understanding Your Options

Let's go through three of the most common frameworks being used as we examine their strengths, limitations, and use cases in modern web automation.

### Selenium

Jason Huggins at ThoughtWorks created Selenium in 2004 (the oldest of the three frameworks). It changed web automation as one of the first complete testing frameworks. It has evolved through multiple versions, with Selenium WebDriver becoming the industry standard. Selenium works with many popular programming languages like Java, Python, C#, Ruby, and JavaScript. This flexibility lets development teams use their preferred languages.

Selenium's architecture consists of the WebDriver for browser-specific automation bindings, Grid for distributed testing, and IDE for record-and-playback functionality. Unlike other tools, it needs different browser-specific drivers (ChromeDriver for Chrome and GeckoDriver for Firefox) to function. While Selenium offers support, its architecture introduces complexity and performance overhead compared to modern alternatives.

Selenium does have some major weaknesses, which includes slower execution speed compared to Playwright and Puppeteer in performance tests, more complex setup and configuration required, lacks advanced features like Playwright's custom selector engines, and does not have deep integration with Chrome's DevTools like Puppeteer.

Let’s examine how Selenium approaches an automation task:
```json
// Selenium

  

import { Builder } from "selenium-webdriver";

import chrome from "selenium-webdriver/chrome";

  

(async () \=> {

// Create new Chrome options

const options = new chrome.Options();

// Create the WebDriver instance

const driver = await new Builder()

.forBrowser("chrome")

.setChromeOptions(options)

.build();

  

try {

// Navigate to the website

await driver.get("https://www.browserbase.com");

// Add any additional automation steps here

} finally {

// Make sure to quit the driver to clean up resources

await driver.quit();

}

})().catch((error) \=> console.error(error.message));
```

Selenium is the most verbose and failure-prone - it requires explicit waits and more setup code, reflecting its enterprise-focused architecture and broad compatibility requirements.

### Puppeteer

Launched in 2017, Google created Puppeteer as a powerful Node.js library specifically designed for automating and testing Chromium-based browsers. Instead of building a separate driver like Selenium, Puppeteer communicates directly with Chrome DevTools Protocol. This allows for more efficient and streamlined browser control.

While Puppeteer only works with JavaScript and TypeScript, it remains a powerful tool for Chromium-specific automation needs, particularly when deep browser integration is required.

However, Puppeteer has limitations as well. This includes limited browser support primarily focused on Chrome and Chromium-based browsers, lacks native mobile app testing features, primarily supports JavaScript limiting language options for developers, and is less suitable for complex end-to-end testing across multiple browsers.

Here's an example of how Puppeteer handles browser automation:

```
// Puppeteer
import puppeteer from 'puppeteer';
(async () \=> {
// Launch a browser instance instead of connecting to BrowserBase
const browser = await puppeteer.launch({
headless: "new" // Use new headless mode
});
// Create a new page (pages() might be empty in fresh browser)
const page = await browser.newPage();
// Navigate to the website
await page.goto('https://www.browserbase.com');
// Close the page and browser
await page.close();
await browser.close();
})().catch((error) \=> console.error(error.message));
```

While more streamlined than Selenium, Puppeteer's Chrome-only focus and lack of built-in smart waiting requires more manual handling compared to Playwright, which is mentioned in the next section.

## Enter Playwright: The Clear Winner

Microsoft released Playwright in 2020. Since its launch, Playwright has evolved to become a comprehensive automation solution.

Built with a more modern architecture, it works across Chrome, Firefox, and Safari browsers, solving a plethora of issues that arose with other contemporaries like Puppeteer and Selenium.

One of the main benefits of Playwright is its simple syntax with powerful abstractions behind the scenes. This lets users write tests that look like real user actions. These actions happen when using a web application. This means that the code is not only easier to read and understand but also more maintainable over time. Developers can easily understand the purpose of the code. This makes it simpler to work with team members or help new developers join.

Let's go through a code example of how Playwright works:

// Playwright

  

import { chromium } from 'playwright';

  

(async () \=> {

// Launch the browser instead of connecting to BrowserBase

const browser = await chromium.launch();

// Create a new context (equivalent to an incognito window)

const context = await browser.newContext();

// Create a new page in the context

const page = await context.newPage();

// Navigate to the website

await page.goto('https://browserbase.com/');

// Close the page

await page.close();

// Close the browser

await browser.close();

})().catch((error) \=> console.error(error.message));

As you can see, the playwright code is more straightforward than any other framework.

These actions happen when using a web application. This means that the code is not only easier to read and understand but also more maintainable over time. Not only do developers easily understand the purpose of the code, this makes it simpler to work with team members or help new developers join.

Browserbase can also serve as a direct substitute for this, enabling you to execute sessions concurrently and perform real-time debugging. This adds more control while being able to have the same functionality as Playwright

## Introducing Stagehand: The AI-Powered Successor to Playwright

Given that Playwright it the most ideal and upcoming framework, Stagehand (stagehand.dev) is the easiest way to build browser automations. You can turn your Playwright code into Stagehand with one line. It is completely interoperable with Playwright and has seamless integration with Browserbase.

Anything that can be done in a browser can be done with Stagehand. Think about tasks like:

1.  Log into Amazon, search for AirPods, and buy the most relevant product
    
2.  Go to Hacker News and extract the top stories of the day
    
3.  Go to ESPN, search for Steph Curry, and get stats for his last 10 games
    

Stagehand offers three simple AI APIs (act, extract, and observe) on top of the base Playwright Page class that provide the building blocks for web automation via natural language. It also makes Playwright more accessible to non-technical users and less vulnerable to minor changes in the UI/DOM.

Stagehand, especially when combined with Browserbase's stealth mode, makes it easier to write durable, performant code that can bypass bot detection and captchas.

## Stagehand in Action

As you can see, the Playwright code is more straightforward than any other framework. The code demonstrates why Selenium is more verbose - it requires explicit waits and more setup code, reflecting its enterprise-focused architecture and broad compatibility requirements. While Puppeteer offers powerful Chrome-specific features, it requires more explicit waiting patterns and additional boilerplate compared to Playwright.

![](https://framerusercontent.com/images/0GSgnTGQhVjFZaWZwBCWcxkwY98.png)

## Start using Stagehand today

If you have Node.js installed, you can easily create a new Stagehand app with baked-in best practices with the following command:

`npx create-browser-app --example quickstart`

Explaining the current automation frameworks and why we recommend Playwright

Choosing between Playwright, Puppeteer, or Selenium? We recommend Playwright

Security in mind from day one
-----------------------------

In October 2024, we announced that Browserbase is SOC 2 Type I certified and HIPAA compliant.

While achieving SOC 2 and HIPAA compliance required dedicated engineering effort, we saw it as a crucial investment. We prioritized these certifications to enable our customers to process sensitive data with confidence, especially as an early-stage company. Our existing security practices made this certification process straightforward, setting a strong foundation for handling mission-critical workloads.

Our Cause
---------

Many organizations recognized how Browserbase could enhance their products and systems. We made it our priority to obtain these certifications so they could seamlessly integrate our platform into their workflows.

This was especially important for healthcare organizations handling Protected Health Information (PHI), where having proper security certifications was essential for enabling collaboration.

We recognized that unlocking these markets required both certifications:

*   Healthcare companies, hospitals, clinics, and pharmaceutical customers needed HIPAA
    
*   Enterprise customers required SOC2 audit documentation
    
*   Many prospects wouldn't even start conversations without compliance
    
*   Certifications served as a competitive differentiator
    

By achieving both SOC2 and HIPAA compliance, we removed these barriers and opened access to more possibilities for these organizations - allowing them to automate workflows where they previously didn’t think possible.

Our Best Practices
------------------

By planning strategically, we completed both certifications in just 2 months instead of the typical 1-2 year timeline.

Getting SOC 2 and HIPAA certified can be daunting for startups, but our early architectural decisions made the process remarkably smooth. Since we’ve had best practices from day one, we built a natural pathway to compliance.

Our core development practices and essential compliance practices set the stage from day one:

*   Enhanced cloud-level security controls
    
*   Documentation of all security incidents and response procedures
    
*   Rigorous code review and automated testing which allowed us to catch issues early through local and pre-merge checks, maintaining consistent quality across our codebase
    
*   Streamlined CI/CD pipelines, multiple testing environments, and documented deployments, alongside full rollback capabilities when needed
    
*   Vendor relationship tracking, defined employee onboarding and off-boarding processes, and mandatory security training for compliance verification
    

Tooling
-------

Scalable compliance requires extensive documentation and tooling to track and verify requirements. This still wouldn’t have been achieved without the team’s work on:

1.  A structured framework with specific compliance tests and tasks
    
2.  Completing tasks for security documentation and policies
    
3.  Having direct system integrations with our core infrastructure to verify compliance requirements
    
4.  Comprehensive tracking of ongoing compliance status
    

Through focused teamwork and our efficient processes, we implemented these rigorous compliance requirements in a short span of time.

This demonstrates our team's ability to execute rapidly and effectively on complex requirements. It showcases not just technical capabilities, but also our commitment to delivering results efficiently while maintaining high standards.

Looking Ahead
-------------

While we've achieved SOC2 Type 1 compliance in record time, we view this as just the beginning. Our current focus is maintaining these standards while planning for the more rigorous SOC2 Type 2 certification that represents our next level of maturity.

As our organization grows, we're strengthening our security infrastructure through enhanced off-boarding protocols and automated access management systems. We're bringing other solutions aimed to bolster our InfoSec capabilities and serve as the foundation of our security program.

Recognizing that compliance requires constant vigilance, we maintain rigorous monitoring and regular updates to uphold our SOC2 and HIPAA standards, ensuring we protect all sensitive data in our care.

To learn more about how Browserbase's HIPAA and SOC2 compliance can benefit your organization, please reach out to our team with any questions.

Having the best security in mind from day one

How we achieved SOC2 and HIPAA compliance in just two months

## The Challenge: Single-Region Growing Pains

When we first built Browserbase, we operated exclusively from AWS `us-west-1`. While this served our initial needs, we quickly discovered a critical limitation: latency. Every request faced a 70-80ms delay, and these delays weren't just adding up—they were multiplying as operations stacked on each other.

As our customer base grew globally, performance emerged as the #1 concern in our feedback. This prompted us to make latency reduction our top priority for Q4.

## Our Investigation

Our investigation took us through various possibilities. We first tried utilizing more resources for our browsers. In addition, we also attempted to remove layers of virtualization.

However, the answer to this problem is distance. Our architecture relied heavily on CDP (Chrome DevTools Protocol) commands—small instructions that needed to be executed sequentially. Each command had to complete before the next could begin, creating a waterfall of delays.

## The Root Cause

![](https://framerusercontent.com/images/SCWbcZ9yfFXAmOEFRSRposZVPyU.png)

User Request -> \[Long Distance Travel\] -> us\-west\-1 -> \[Processing\] -> \[Long Distance Travel\] -> User Response

Whether a customer was in London, Tokyo, or New York, their requests had to make a longer journey to where servers were running, `us-west-1`.

That means for users in Singapore, this meant their browser commands were traveling nearly halfway around the world—and back—for every single operation.

## Multi-Region

Looking at our latency data, we realized we needed to shift our infrastructure strategy. Instead of optimizing traffic through a single region, we needed to rethink how we could minimize the physical distance between our customers and their browser sessions.

**The solution became clear**: rather than forcing all users to connect to a single point, we needed to bring our browser infrastructure closer to where our customers operate.

The entire migration took just one month to implement, proving that sometimes the most impactful solutions aren't the most complex. Below, we’ve expanded our infrastructure to multiple strategic locations worldwide:

![](https://framerusercontent.com/images/Xkqwo5nwiDEsPN4v1JTuje1KNgQ.png)

![](https://framerusercontent.com/images/1nngE0vZaAoEgRLLw20Eoz9dQ.png)

## The Numbers

To validate our multi-region approach, we ran tests using a sample web scraping script that performs multiple CDP operations.

We tested this script from different locations connecting to both nearby and distant regions.

The script performs multiple sequential operations - waiting for elements, selecting DOM nodes, and extracting data - each requiring multiple CDP commands to complete.

To summarize the results:

*   **More than 2x faster** task completion for users connecting to their nearest region
    
*   **Reduced resource consumption** due to faster task completion
    
*   **Lower costs** for customers through improved efficiency
    

### Before vs After Comparison

**Before (Single Region -** `**us-west-1**`**):**

Eastern US (us-east-1) → us-west-1: ~63ms latency

Western US (us-west-2) → us-west-1: ~23ms latency

Frankfurt (eu-central-1) → us-west-1: ~152ms latency

Singapore (ap-southeast-1) → us-west-1: ~169ms latency

Each command must wait for the previous one to complete and every command faces this round-trip latency. Below are the improvements after we’ve implemented multi-region:

**After (Multi-Region):**

With our multi-region deployment, users can specify their preferred region when connecting. By choosing a server closer to their location, they can significantly reduce the distance each CDP command needs to travel.

Here's what the latency looks like when users connect to their local regions instead of routing everything through `us-west-1:`

New York → us-east-1: ~6ms latency

Frankfurt → eu-central-1: ~3ms latency

Singapore → ap-southeast-1: ~5ms latency

Tokyo → ap-northeast-1: ~4ms latency

**This represents a dramatic improvement:**

Eastern US users: 90% reduction in latency (63ms → 6ms)

Western US users: 87% reduction in latency (23ms → 3ms)

European users: 98% reduction in latency (152ms → 3ms)

Asian users: 97% reduction in latency (169ms → 5ms)

It’s important to remember that these latencies compound with each CDP command, so the real-world performance improvement is even more significant when running complex browser automation tasks that require multiple sequential commands.

## Best Practices for Customers

To get the most out of our multi-region infrastructure, we recommend:

*   Choose the region closest to your primary user base
    
*   For applications serving global users, consider using multiple regions
    
*   Monitor latency metrics to ensure optimal performance
    
*   Contact our support team for region-specific optimization advice
    

The switch to multi-region is straightforward. When creating a new browser session, simply specify your preferred region using the `region` parameter in your API request.

Here's how to create a session in `us-east-1` using a curl request:

curl --request POST \\\\

\--url <https://www.browserbase.com/v1/sessions> \\\\

\--header 'Content-Type: application/json' \\\\

\--header 'X-BB-API-Key: YOUR\_BROWSERBASE\_API\_KEY' \\\\

\--data '{

"projectId": "<YOUR\_BROWSERBASE\_PROJECT\_ID",

"region": "us-east-1"

}'

We have a dedicated page for how to use Multi-Region capabilities here.

For best results, we now recommend that customers simply choose the location nearest to them when using our service. While our main location is still in the Western USA (`us-west-2`), you can choose any of our locations to get the best possible performance for your needs.

## Looking Forward

We are continuously monitoring usage patterns and performance metrics to identify potential new regions and further optimize our existing infrastructure.  
  
For more information, visit Browserbase to learn more!

The Browser Blog

An Internet Browser for AI

An Internet Browser for AI

Read Article

Organizations are coming June 4th

Read Article

Unit-testing AI Agents in the Browser

Read Article

Stagehand gets even better – The AI Web Agent SDK

Read Article

Browserbase named #1 on the Enterprise Tech 30 list

Read Article

What is a headless browser?

Read Article

The Browserbase Free Plan (Finally!)

Read Article

Choosing between Playwright, Puppeteer, or Selenium? We recommend Playwright

Read Article

How we achieved SOC2 and HIPAA compliance in just two months

Read Article

Becoming Multi-Region

Read Article