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

>Try our new product, [Director.ai](https://director.ai) today

In this hyper-fast world of AI, in order to compete you have to keep up. Even since starting Browserbase 16 months ago, I’ve seen the promises of AI turn into production-ready reality. 

We're proud to be part of this transformation, building the infrastructure that makes web automation accessible to everyone. What started with a thesis that AI agents would require great browser infrastructure, has turned into billion dollar companies using Browserbase to deliver better outcomes for their customers.

## Building on a foundation of primitives

The most transformative technology companies (Twilio, Stripe, Vercel) all share something in common: they're primitives. They provide the fundamental building blocks that enable developers to create powerful applications.

Browser infrastructure represents the next critical primitive. It's the foundation that will change how people interact with and automate the web, empowering developers to build software that fundamentally transforms online work.

## The opportunity ahead

Think about how often we interact with a web browser: buying products, sending messages, deploying code. Now consider all the routine online tasks, from sending emails to booking travel, that consume our time every single day.

The future of browsing is selective automation. Humans will still do the joyful, discovery-driven tasks. But repetitive, time-consuming work should be done by software. That’s what we’re building for.

This vision where AI handles the boring parts while humans focus on what matters, represents a massive business opportunity. If Browserbase can become the rails of this new era, we'll be enabling an entirely new category of applications.

And yes, maybe developers are inherently lazy, we build tools to avoid repetitive work. Browserbase is the ultimate expression of that philosophy.

## Expanding our platform

Along with our Series B announcement and lots of small product improvements, we're announcing three main platform upgrades:

1. [**Director.ai**](http://director.ai/): Browserbase has always been built for developers, and we plan to always help developers automate the web, but in this era of AI, everyone can be a developer. And that's why we're launching Director. Director is here to let anyone automate the web, generate Stagehand scripts and deploy them on Browserbase. It's empowering. And it's transformational for infrastructure companies like us, which traditionally only sold to developers, but now we can sell or support everybody. I think that's monumental.
2. **Stagehand for Python**: We're now working with two of the most popular programming languages, Python and Node.js. And I'm very excited for that. The Python version also comes with enhanced observability features built into the Browserbase dashboard, including session recordings, token usage tracking, and comprehensive logging.
3. **We're lowering our prices**: We've been hard at work improving our infrastructure to continue to offer better pricing and value. We hope to make automation a more accessible tool for all builders. Here are the key changes, but you can see all the details here. 
    - **~~Hobby~~ Developer plan**: 50% price reduction to get started, from $39 to $20/month for 100 browser hours and 1 GB of proxies.
    - **More concurrent browsers**: From 3 to 25 on the Developer plan & doubled concurrency from 25 to 50 browsers on the Startup plan.
    - **New feature**: Variable-size browsers for scale customers, choose from our pre-configured small, medium, or large instances.


 ## Series B & beyond

The product release coincides with a $40 million Series B financing round led by Notable Capital, with participation from existing investors CRV and Kleiner Perkins. This new funding marks our commitment to the long haul. Our team, investors, and most importantly, our customers share a vision of a future where people operate with unprecedented leverage through intelligent automation.

The journey ahead is substantial. Browser infrastructure still needs deep innovation—in the browser technology itself, the surrounding infrastructure, and all the supplemental features required to build powerful applications on this foundation.

The market opportunity attracts competition, which we welcome. In markets this large, innovation benefits everyone, pushing the entire ecosystem forward and delivering better solutions for customers.

Looking ahead to the next year at Browserbase, our mission remains clear: help everyone automate the web. We're building the best browser infrastructure platform, the most powerful framework, and the most accessible application to make that vision reality.

We can't wait to see what everyone builds.

We're excited to announce our Series B funding, major platform updates, and our plans for building the primitive infrastructure that will enable AI to automate the mundane work we do online every day.

Building the Future of Web Automation

I am excited to announce our newest product in the Browserbase family of products. You might know us for Browserbase, our headless browser infrastructure, or Stagehand, our browser automation framework. But today we're introducing Director, which lets anyone automate the web using a natural language prompt. You can now generate repeatable web automation code in one single step.

## A New Direction for Browserbase

Director is a huge step for Browserbase as we move from being just an infrastructure platform to enabling anybody to automate the web. This is challenging for us because we sell to developers and we are developers ourselves. So building a product that's built for everybody—even people not familiar with programming—required us to rethink everything from the ground up.

Now, Browserbase the infrastructure platform and Stagehand the framework are still a top priority for our company. And they're the building blocks that Director uses to help people automate the web.

## How Director Works

You see, Director makes it so you don't have to start writing code to use Browserbase. You can start with the task that you already know—the boring work that you want to automate. And then, using AI by chatting with the application, it outputs a Stagehand script that controls the browser.

Where's that browser running? Browserbase—the best infrastructure platform for running browsers at scale in the cloud.

## Why We Built Director

We built Director because we continue to meet people who had heard about Browserbase and were somewhat technical and familiar with AI, but didn't have the right tools or were using maybe the wrong tools designed for other types of infrastructure to try and build out integrations and try and build automations.

But now with Director, it's never been easier to get started.
## Looking Ahead

We have great plans for this product. And today's announcement is only the very beginning of what we plan to do with it, so stay tuned. 

Director is going to be the best way to get started. And even if it isn't the final version of your feature that automates the web, it's a great way to begin.

Everyone is a developer in the age of AI. And that means everyone can use Director.

I can't wait to see what you build.

I am excited to announce our newest product in the Browserbase family of products. You might know us for Browserbase, our headless browser infrastructure, or Stagehand, our browser automation framework. But today we're introducing Director, which lets anyone automate the web using a natural language prompt. 

Introducing Director: Web Automation for Everyone

Beatriz Go

> *"The story is simple - it went well." - Qian, Head of Engineering*
> 

Convergence built a revolutionary web agent platform that automated daily tasks for consumers across the web. By leveraging Browserbase's unique live session capabilities and residential proxy infrastructure, Convergence scaled to 200,000 users before being acquired by Salesforce. 

## The vision: A generic web agent for everyone

Convergence set out to solve a fundamental problem in consumer productivity: the endless repetitive tasks that consume people's time online. Their platform enabled users to delegate complex web-based workflows to AI agents that could navigate websites, extract information, send emails, and interact with applications.

The goal was to build a web agent that could handle any task a user might need - from reading news and extracting information to managing professional workflows across multiple platforms. This wasn't just about simple automation; it was about creating intelligent agents that could adapt to different websites and handle complex, multi-step processes.

## The technical challenge: Beyond basic browser automation

Building a consumer-facing web agent presented technical challenges that traditional headless browser solutions couldn't address. The team quickly realized they needed capabilities that went far beyond simple automation.

### The critical missing piece: Human-in-the-loop functionality

Even the most sophisticated AI agents sometimes need human intervention. Users needed to be able to jump into browser sessions to handle edge cases like:

- Entering credentials for sensitive accounts
- Addressing unexpected authentication flows
- Handling complex forms that required human judgment

### Initial attempts and their limitations

The team initially explored a competitor, which provided headless browser capabilities but lacked this live session functionality that was crucial for their vision. While they could handle basic automation, it couldn't provide the seamless handoff between AI and human that Convergence's users needed.

This limitation would have fundamentally constrained their product vision, forcing them to either:

- Build complex workarounds that degraded user experience
- Limit their platform to simpler use cases that didn't require human intervention
- Invest significant engineering resources in building their own live session infrastructure

## Enter → Browserbase: Everything they needed in one platform

The discovery of Browserbase came at a critical moment and was seamless to setup. 

> "We went through the documentation and found this live session thing, and it was very useful. It took us very minimum time to set it up compared to what we’ve tried in the past.”
> 

The partnership enabled Convergence to scale rapidly without having to deal with the challenges of self hosting. The platform's reliability and scalability meant they could focus on AI agent development rather than browser infrastructure.

### The numbers:

- **200,000 total users** at the time of acquisition
- **8,000-9,000 daily active users** running tasks continuously
- **3-4 engineers saved** from having to build custom browser infrastructure who could instead focus on the core product

### The competitive advantage: comprehensive features & true partnership

Browserbase's comprehensive feature set became a key differentiator for Convergence. While competitors struggled with basic browser automation challenges, Convergence could offer sophisticated human-in-the-loop capabilities and reliable access to major platforms.

> "Without Browserbase, there would be a lot of headaches. The features Browserbase provides like CAPTCHA solving and live session URLs, they're not trivial. Browserbase definitely helped a lot."
> 

Beyond the technical capabilities, the partnership with Browserbase stood out for its personal touch and responsiveness to customer needs.

> "Our requests were treated seriously. You don't want to build a partnership where they just charge you and don't do anything."
> 

This relationship-first approach proved crucial as Convergence scaled. When they needed specific features or infrastructure improvements, Browserbase treated them as partners rather than just customers, implementing solutions that supported their growth.

## **The Salesforce acquisition: Scaling to enterprise B2B**

Convergence's success with Browserbase-powered web agents caught the attention of Salesforce, leading to an acquisition that will integrate the team into Salesforce's Agent initiatives.

## **The future: Enterprise-grade web agents at Salesforce scale**

Convergence's journey demonstrates how the right infrastructure partnerships can accelerate growth and enable ambitious technical visions. The continuation into their Salesforce era shows the enduring value of reliable, scalable browser infrastructure.

*"We don't want to hire people to build headless browser service ourselves. Plus, all the features Browserbase adds on top of it - it would just cause us headaches. We'll just use Browserbase.”*

---

**Ready to build AI agents?** Join companies like Convergence who are transforming how they use the web to drive business impact.

[Get started with Browserbase →](https://browserbase.com/)

B2C web agent startup scales to 200,000 users before Salesforce acquisition, powered by Browserbase's human-in-the-loop capabilities

How Live View Became Convergence's Secret Weapon

Benny has revolutionized how food stamp recipients access deals and manage their finances. By leveraging Browserbase's headless browser infrastructure and Stagehand's AI-powered automation, Benny transformed a maintenance-heavy scripting nightmare to a self-healing platform that allows it to onboard new grocery merchants in a day instead of weeks..

## Financial data without APIs

Benny serves the 42 million Americans who receive SNAP benefits (food stamps) by allowing them to link their grocery loyalty accounts (Walmart, Kroger, H-E-B, and more) to earn unique brand deals and promotions.
The core challenge lies in accessing data that traditionally doesn't have APIs, like merchant loyalty accounts that Benny needs to sync users' purchase history to deliver personalized promotions. This requires constant browser automation across dozens of different merchant portals, each with unique authentication flows and data structures.

> "Our core competency is financial services, so we're really appreciative of Browserbase that allows us to abstract away the difficulties of getting data that traditionally doesn't have APIs," explains Steve, CTO and co-founder of Benny.

## Benny's initial attempts

Like many others, Benny initially tried building their own browser automation infrastructure from scratch. The team started with AWS Lambda, attempting to host Chromium directly while patching together various tools and managing their own proxy providers. This approach quickly proved untenable for an engineering team focused on financial services innovation.
The team then moved to another browser infrastructure company, but found the platform lacking in key areas. "We just didn't find that they were keeping up to date in terms of observability, stealth capabilities, and tooling that Browserbase offers, plus transparency around pricing," Steve recalls.
But the real problem wasn't just infrastructure - it was maintenance, and therefore, time. Benny relied heavily on brittle Playwright scripts with complex retry workflows. When pages changed slightly, workflows would fail, requiring engineers to investigate, fix, and restart processes. This created a vicious cycle where customer-facing engineers were constantly pulled away from core product work to patch up automation scripts.

> "Engineers weren't happy because this pulled them away from their core project work. Customers weren't happy because data was delayed," Steve explains.

The traditional solution for companies in Benny's space would be hiring a dedicated team focused solely on browser automation scripts. But Benny knew there was another solution.

## The Browserbase + Stagehand combo

The migration to Browserbase provided immediate infrastructure reliability, but the real transformation came with Stagehand's AI-powered automation capabilities. Instead of writing and maintaining brittle Playwright scripts, Benny could now leverage AI agents that adapt to page changes automatically.
The change was dramatic and immediate! Instead of complex forking logic to handle different page renderings for different customers, Stagehand's AI could analyze pages dynamically and extract the needed data regardless of layout variations. What previously required extensive scripting now worked with simple prompts and extraction logic.

> "We frankly barely write any traditional Playwright scripts at all now," Steve explains. "Before, data extraction required looking at all possible page combinations and writing tons of forking logic - a total mess to write and maintain. Now we can spin up a new merchant link quite quickly, release to production quickly, and it's largely issue-free from the get-go."

The reliability improvement was equally striking. Professional infrastructure management combined with self-healing AI automation meant consistent uptime and minimal manual intervention. Most importantly, Benny's engineers could focus on building financial services features instead of debugging web scraping scripts.

### Now Benny can scale financial data access with a lean team
> "We were going to hire a full-time engineer to manage all of this, and we're not now because of Browserbase and Stagehand."

The impact of migrating to Browserbase has driven market expansion and saved developer time.

### Engineering time saved
* 4-5 hours to 15 minutes weekly: Maintenance time per script dropped from 4-5 hours weekly across a 4-person engineering team to just 15 minutes
* 1-2 weeks to 1 day: New merchant onboarding time reduced by 90%
* 30 minutes to under 1 minute: Issue diagnosis time thanks to Browserbase's replay functionality and real-time observability
* Avoided additional hires: Eliminated need for dedicated infrastructure engineer whose sole job would have been to maintain their browser infrastructure
* Robust Data Extraction: Stagehand handles complex page variations and conditional logic automatically
* Scalable Architecture: Infrastructure that grows with business needs without proportional engineering overhead

### Bottom line business impact
* Faster Market Expansion: Ability to quickly add new merchants and brands to the platform
* Improved Customer Experience: Consistent data synchronization without delays from broken scripts
* Engineering Focus: Team can concentrate on core financial services features instead of maintenance

## AI-powered financial services & more

Benny's story demonstrates how AI-powered browser automation enables fintech companies to access critical data sources without building massive overhead. The combination of reliable infrastructure and intelligent automation creates a competitive advantage in markets where data access is traditionally complex and expensive.

As Benny prepares to launch more products in the market, Browserbase + Stagehand provides the foundation for rapid scaling.
> "I love the product. Browserbase has allowed us to abstract away the difficulties of getting data that traditionally doesn't have APIs, and Stagehand has made our automation largely issue-free from the get-go." — Steve, CTO and Co-founder, Benny

---
**Ready to build your own consumer platform system?** Join companies like Benny who are transforming how they use the web to drive business impact. 

[Get started with Browserbase →](https://browserbase.com/)


AI-powered browser infrastructure enables rapid merchant onboarding for SNAP benefit platform

5 Hours to 15 Minutes: How Benny Eliminated Automation Maintenance Overhead

Anirudh Kamath

Miguel Gonzalez

![](https://cdn.sanity.io/images/v773ixxh/staging/5e6c45d71545c4ccbbf13fa003d2bbec8c27cf06-2000x1248.png)

# **A Modern Platform for Intelligent Automation**

Imagine you want to automatically test your app's checkout flow every hour, gather competitive pricing from a dozen websites, or guide new users through your product. Historically, the technology to do this has been brittle, slow, and a frustrating "black box" when things go wrong, making it difficult to trust for important business tasks.

At Browserbase, we’re hell-bent on shining a light on this black box. We power browser solutions for AI leaders like Vercel, Perplexity, and Clay, and our recent Series B round at a $300 million valuation has allowed us to perfect this next-generation platform for web automation. Our open source framework, Stagehand, is the most downloaded framework for automating browsers with AI.

We’re attacking this problem with a complete, modern platform where three powerful components work together seamlessly:

1. **Browserbase** (”the where”) — Think of this as the industrial-scale cloud foundation. We host and manage massive fleets of secure, ready-to-use browsers, so your team doesn't have to worry about servers, scaling, or maintenance.
2. **Stagehand (**”the what”), our open-source toolkit that defines *what* you want to do. Using simple, intelligent commands like `act` (to perform an action) and `extract` (to get data), your team can easily define any workflow.
3. **[NEW] Stagehand API** (”the how”) is the intelligent engine that controls *how* it all gets done. This API is the core of our platform, taking your Stagehand prompts, translating them into precise browser commands, and optimizing their execution on the Browserbase infrastructure for maximum speed and reliability.

It’s this deep integration of the Stagehand framework (the what), the intelligent Stagehand API (the how), and the Browserbase infrastructure (the where) that creates an impactful unified solution.

## Business Impact

This new platform does more than just automate tasks; it changes how you can rely on and learn from your automation efforts. The business impact is clear and immediate.

**You get actionable insights, not opaque logs.** Instead of confusing CDP traces, the Stagehand API creates a clear, human-readable log of every action. You can see exactly what instruction was sent to the LLM, what was returned, and how many cache hits you got, making it incredibly easy to diagnose issues. Your team can now pinpoint and fix problems in minutes, not hours, leading to less downtime and a better user experience.

![CleanShot 2025-06-12 at 15.21.09@2x.png](attachment:e5b5f96c-4edc-47c8-a36f-16ea1eb96a27:8d40ed74-4c0c-4ab4-aa04-427432f20fce.png)

**Your automations learn and heal.** The Stagehand API is designed for efficiency and resilience. For workflows that you run repeatedly, we can securely **cache** actions to make them faster and cheaper over time. If it encounters a small error, like an element not loading instantly, it can often **self-heal** by intelligently retrying the action without any human intervention, making your automations incredibly robust.

**You get built-in intelligence with zero effort.** The world of AI is complex, but your team doesn't need to be AI experts to get expert results. The Stagehand API acts as a navigator, **automatically routing** your request to the best AI model for the job—whether for understanding natural language or analyzing a webpage's layout.

**Better cross-platform support.** The Stagehand API being a fully hosted solution enables better cross-platform support for things like multi-language support, better MCPs, and whatever else you may use AI browsers for!

---

# Engineering Deep Dive


## The Old Way: A "Black Box" Problem

Observability is one of the clearest wins we’ve enabled with the Stagehand API. Previously, in a typical setup, an engineer writes a Stagehand script with a high-level command like `page.act("click the quickstart button")`. That command is translated into a series of very low-level, technical instructions using the [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/) that are then sent one-by-one over a websocket to the browser using [Playwright](https://playwright.dev/).

![](https://cdn.sanity.io/images/v773ixxh/staging/e4ae022c7a66dde6e26296a88cc6a41da7959a0a-5462x2190.png)

The critical issue here is a communication breakdown. The browser only receives the low-level CDP commands and has no knowledge of the original, high-level goal. The "why" behind the action is completely lost during the translation process.

As a result, when you try to review or debug a failed automation, the session replay is just a stream of these opaque, technical traces. It tells you what happened at a micro-level, but it’s impossible for a person to look at and quickly understand the business step that failed.

![](https://cdn.sanity.io/images/v773ixxh/staging/286f72963a97316396b4261b8938c2148e1a1d3f-2000x1249.png)

This problem is a direct result of a flawed architecture where all the complex work happens on the user's side. This design is not only inefficient and slow due to every instruction traveling across the internet, but it's also the source of the debugging black box.

## The New Way: Stagehand API on Browserbase

Instead of sending low-level instructions, client-side Stagehand can now send a single, high-level Stagehand command — like "click the quickstart button" — directly to our Stagehand API. 

The Stagehand API receives this request, translates your goal into the necessary low-level CDP actions, and directs a Browserbase browser to execute them.

![](https://cdn.sanity.io/images/v773ixxh/staging/c35ab25765dddf88b881a0836dfd8b390b9f2626-5424x3290.png)

The difference is that all the complex translation work now happens on managed infra, allowing us to actually view meaningful LLM traces. 

![](https://cdn.sanity.io/images/v773ixxh/staging/3171febe11836a18b6af37e7e849554ff0bdb394-2000x1243.png)

***We are now able to get crucial information on what the user is specifically asking for, and we can intelligently handle the request to generate an optimal response!*** 


## Conclusion: A New, Clearer, Headache-Free Path for Browser Automation

By combining our intelligent Stagehand framework with a powerful, purpose-built API, we provide a complete solution that transforms automation from a fragile script into a core, strategic, and reliable part of your business operations. This new approach delivers the simplicity, clarity, and resilience needed to automate with confidence.

Get started now: `npx create-browser-app`

Browserbase introduces the Stagehand API, a modern platform that combines cloud infrastructure, an open-source toolkit, and an intelligent engine to revolutionize browser automation. The platform transforms traditionally brittle and opaque automation processes into reliable business operations by offering improved observability, self-healing capabilities, and built-in AI intelligence.

Introducing the Stagehand API

Chronicle Legal has revolutionized how disability attorneys manage and analyze evidence from government portals. By leveraging Browserbase's headless browser infrastructure, Chronicle transformed a tedious self-hosted, and breakable solution to a scalable platform serving firms with thousands of active cases, all while maintaining a lean operation.

## Antiquated government systems 🤝 modern legal needs

Disability attorneys represent clients seeking Social Security disability benefits. Their firms manage hundreds to thousands of active cases simultaneously, each lasting an average of 18 months - this comes with a unique operational challenge.

The core problem lies in how evidence and case updates are delivered. The government provides crucial information through an antiquated portal called ERE, but offers no notifications or automated updates. Attorneys must manually check each case daily, logging into the portal and reviewing tables of documents, evidence, and notices to identify new information. Their only other alternative is … to wait for the mail. These professionals thus must spend excessive time on these administrative tasks rather than on case preparation.

> "The average firm has 200 active cases at any time, but some of our firms have 6,000 cases," explains Nikhil Pai, founder of Chronicle. "It was never possible for firms to actually do this level of monitoring. They would always wait for the mail, which would get lost or delayed, causing them to miss deadlines."

## Chronicle's initial solution & its challenge

Chronicle wanted to develop a comprehensive platform that automated the entire evidence monitoring and analysis process. Nikhil initially tried to build the browser infrastructure required for this automation from scratch. However, he learned early on that it would not be a viable long term solution. 

Initially, this workflow was built using a self-hosted Selenium Grid setup. Nikhil built his own browser infrastructure using Celery workers managing Selenium Grid. He ran his own hardware and needed to monitor instances, and the task queue, and had to deal with memory management and CPU management. With the first handful of customers, it worked well enough.

But as Chronicle grew, Nikhil knew that this was untenable. Even with 20 customers, Chronicle would be running a couple hundred sessions a day, quickly forcing him into daily "infrastructure babysitting." 

The rigid one-to-one worker-to-browser architecture meant that if 10 browsers were running but 5 crashed, his effective capacity dropped by half, creating hours-long backlogs.

"I was constantly checking: Is Selenium running? Do I have enough browsers?" Pai recalls. Each new client required manually provisioning containers and monitoring memory usage. Worse, the system lacked stealth capabilities - a ticking time bomb as government portals inevitably added bot detection.

The infrastructure demands were consuming increasing amounts of his time, preventing focus on core product development. 

## Enter → Browserbase

Having struggled with his own infrastructure for months, the promise of managed browser infrastructure was immediately compelling. The migration proved transformative. Nikhil took the opportunity to modernize his entire stack and the Browserbase API replaced his complex container orchestration entirely.

The change was immediate and dramatic. No more manual browser management. No more capacity planning. No more hung browsers derailing operations. "Now I can just pay you guys more money and get more browsers," Pai explains. 

> **If he needed 50 workers instantly, 50 browsers were ready and available.**

The reliability improvement was equally striking. Professional-grade infrastructure meant consistent uptime, with only one outage experienced since adoption. Built-in stealth capabilities provided future-proofing against evolving government security measures. Most importantly, Nikhil could finally focus on what mattered: building his core product and growing the business instead of babysitting infrastructure.

## Now? Scaling to enterprise levels with a lean operation

> **This has saved me at least a month’s worth of time to set up our own infrastructure to make it more robust. But really, it’s hard to measure peace of mind. The key is that I no longer have to think about this.**

The impact of migrating to Browserbase has driven business impact and saved developer time. 

### 1. Business Impact

- **Competitive Advantage**: Superior browser infrastructure became a key differentiator, enabling service levels that competitors couldn't match. "My competitor without Browserbase is not able to achieve the service level I can because they don't have the browser infrastructure," Nikhil explains
- **Unlimited and Automatic Scaling**: No more manual browser management. This allows taking on larger clients without infrastructure concerns
- **Service Reliability**: Chronicle no longer worries about browser infrastructure reliability & the elimination of browser maintenance overhead
- **Lean operation**: Browserbase enabled to handle enterprise-level workloads without adding DevOps or infrastructure engineering roles.

### 2. Development Efficiency

- **Months of development time saved**: Avoided building robust scaling architecture that may or may not have worked
- **Peace of Mind**: No longer worrying about browser infrastructure reliability
- **Focus on Core Product**: More time spent on AI features and user experience
- **Future-Proofing**: Built-in capabilities like stealth mode provide protection against evolving technical challenges in government portal automation

## Why Browserbase over others?

Browserbase’s differentiators came down to integrations, cost, and developer experience. 

> **"Nothing I could find easily plugged into having your own Playwright code," Pai explains. "Other options required using their proprietary language or being locked into their ecosystem. I already had most of the code in place, so it wasn't worth rewriting everything."**

Browserbase's competitive pricing model aligned with Chronicle Legal's bootstrap, single-founder approach while providing enterprise-grade capabilities. This plan also includes direct access to the Browserbase team and responsive support has been crucial for a developer managing a complex technical product.

### Build your own enterprise grade solution

Chronicle's story demonstrates how Browserbases’s modern infrastructure services enable lean teams to build and scale enterprise-grade solutions. 

*"Without a tool like Browserbase, it would have been very difficult to scale the business while staying as a single person. The fact that I can run 100,000 sessions per month is not possible with my own architecture. Browserbase enabled me to make browser reliability and scale a unique selling point of my product."*

**- Nikhil Pai, Founder**

---
**Ready to build a legal platform?** Join companies like Chronicle who are transforming how they use the web to drive business impact.

[Get started with Browserbase →](https://browserbase.com/)

Founder builds scalable disability law automation using Browserbase that competitors "cannot achieve"

How Browser Infrastructure Became Chronicle Legal's Competitive Moat

Sean McGuire 

Iframes (or as I like to call them: cry-frames) are unavoidable in the world of web automation. Iframes are basically just mini-websites embedded in other websites; anytime you've seen "embedded" content like a tweet or YouTube video, that's an iframe. They are simultaneously a super convenient tool for web developers, and a source of existential despair for automation engineers. 

<iframe src="https://link.excalidraw.com/readonly/Rh8AsVAEJUjmVjcPngNk" width="100%" height="100%" style="border: none; min-height: 500px"></iframe>

Writing an automation script for a site loaded with iframes feels like cooking one meal across multiple kitchens simultaneously. Each kitchen appears identical, but surprise! They all have completely different ingredients. Sometimes, there are even secret kitchens hiding inside other kitchens. Handling iframes, even in established browser automation frameworks like Playwright, Puppeteer, and Selenium, is a common point of confusion for people developing web automations. This post is about how Stagehand changed that. 

### A quick aside on Playwright and CDP

Playwright is a browser automation framework developed by Microsoft that lets developers script and control real browsers like Chrome, Firefox, and Safari. It is most popular for end-to-end testing, but its also commonly used for tasks like web scraping, performance monitoring, and automating routine web workflows. Under the hood, Playwright uses the Chrome DevTools Protocol (CDP) [[2]](https://www.notion.so/Iframes-blog-post-2083c11b66148001995acb820c56bbfa?pvs=21)  to talk directly to Chromium-based browsers, but it abstracts away that complexity with a clean, high-level API. For example, instead of manually sending CDP commands, you can just use `page.click('#submit')` or `page.locator('input[name="email"]').fill('user@example.com')`. 

## How Stagehand makes complex web pages LLM-parseable

First, Stagehand uses the `Accessibility.getFullAXTree` CDP command, which returns a structured set of Accessibility Nodes (`AXNode`). These nodes come with rich semantic details about every interactive or structural element on the page, including their roles (like buttons, links, or input fields), names, labels, and states. Here’s an example of an `AXNode`:

```json
{
  "nodeId": "30",
  "role": { "value": "button" },
  "name": { "value": "Apply for this Job" },
  "properties": [
      {"name": "focusable", "value": {"value": true}}
  ],
  "backendDOMNodeId": 30
}
```

Second, Stagehand uses `DOM.getDocument`, to get the full hierarchical structure of the DOM starting from the root node. A DOM node looks something like this:

```json
{
  "nodeId": 42,
  "parentId": 41,
  "backendNodeId": 3,
  "nodeType": 1,
  "nodeName": "BUTTON",
  "localName": "button",
  "nodeValue": "",
  "childNodeCount": 2,
  "children": [...],
  "attributes": [
    "class",
    "_button_8wvgw_29 _quaternary_8wvgw_91    _back_14ib5_49 ashby-job-board-back-to-all-jobs-button"
  ]
}
```

Stagehand then combines these data sources to create a hierarchical string representation of the page. This representation makes the page understandable and actionable for the LLM. Here’s a small snippet illustrating this structure:

```
Accessibility Tree: 
[1] RootWebArea: Careers at Y Combinator | Y Combinator
  [7] scrollable
    [311] div
      [314] banner
        [315] navigation
          [316] div
            [318] link: Y Combinator
              [3] image: Y Combinator
            [319] div
              [321] link: About
              [339] link: Companies
              [351] link: Startup Jobs
              [371] link: Find a Co-Founder
              [377] link: Library
              [383] link: SAFE
              [389] link: Resources
          [419] link: Apply
...
```

Stagehand also uses this information to construct an ID → XPath map. When the LLM selects an element by its ID from this structured representation, Stagehand quickly retrieves the corresponding XPath and executes the desired action.

Yet, [Playwright and CDP don’t always play nicely together](https://github.com/microsoft/playwright/issues/30261#:~:text=Interoperating%20with%20CDP%20is%20not%20a%20goal%20for%20Playwright), particularly around iframes:

- **Managing contexts [[1]](https://www.notion.so/Iframes-blog-post-2083c11b66148001995acb820c56bbfa?pvs=21):** Want to send a CDP command to a specific iframe? Now you have to handle the CDP session context yourself—goodbye Playwright’s magical auto-context switching.
- **Frame IDs:** Playwright doesn’t expose stable IDs for frames. This omission complicates creating composite IDs.
- **Node IDs aren’t unique across iframes:** The backendNodeId provided by CDP, which Stagehand relies upon internally, is not globally unique across iframes. The same ID might point to two entirely different elements in different iframes, causing major ambiguities.

So how can we enable users to `extract`, `observe`, and `act` upon elements in deeply nested iframes?

## Why iframes are so painful

Users just want to be able to write Stagehand code like this:

```tsx
await page.act({
  action: "click the submit button",
  iframes: true,
});
```

Since Stagehand operates primarily on the HTML body tag, it’s relatively easy to resolve a natural language command to a Playwright-compatible DOM selector.

However, with iframes, you don’t know exactly where your element lives, and we don’t want Stagehand users to tear their hair out trying to get the right DOM selectors. A major part of the value of Stagehand is to free users from the tedium of manually finding elements, frames and selectors.

Assuming you know what selectors to use, here is what clicking inside of a nested iframe might look like with playwright:

```tsx
  const inner: FrameLocator = page
    .frameLocator('iframe.lvl1')  // level 1
    .frameLocator('iframe.lvl2')  // level 2
    .frameLocator('iframe.lvl3'); // level 3 – form lives here

  await inner.locator('button[type="submit"]').click();
```

### The Solution: One Tree to Rule them all

Previously, Stagehand only operated on the root DOM. Now, Stagehand systematically traverses through every frame, both same-process and out-of-process iframes (OOPIF). This traversal is done through a depth-first search:

1. We start at the main document and recursively explore each child frame.
2. For each frame, we capture its accessibility tree and calculate an absolute XPath pointing to its iframe element within the parent frame.
3. We construct a snapshot containing each frame’s simplified tree (hierarchical string representation), XPath mappings, and URL mappings.
4. Each snapshot is tagged with a unique EncodedId—combining a frame ordinal and node ID—to guarantee global uniqueness.
5. Finally, these snapshots are stitched together into a single, combined accessibility tree. The resulting unified representation ensures all elements, regardless of nesting depth, are accurately identifiable and interactable by Stagehand.

### **Globally Unique IDs**

To preserve uniqueness of nodes across iframes, we assign each one a simple composite ID: a frame ordinal combined with its backend node ID. This gives us a stable way to distinguish otherwise identical node IDs that come from different frames.

### **Deep XPath Locator**

To reliably find elements within nested iframes, we added a “deep” XPath locator. It works by breaking the XPath into chunks, and every time it hits an `<iframe>` step (like `/.../iframe[2]/../...`), it uses Playwright’s frameLocator() to descend into that frame. It then continues building the path inside that new context. For an XPath like `/html/body/iframe[2]/iframe[1]/div[3]`, the deep locator would handle each iframe hop internally and return a working Playwright Locator for the final element.
	
###  **CDP Session Management**

We updated how CDP sessions are managed by tying each session directly to its corresponding Page or Frame. Internally, we use a WeakMap to store sessions per frame, so we can easily look them up when needed without keeping extra references around. This makes it easier to send CDP commands to the right frame, especially when dealing with nested or out-of-process iframes.

### End-User Impact

- `extract` now sees everything.
- `observe` produces xpaths for elements across all frames.
- `act` can traverse and act upon elements across all frames.

Most of all, you don’t need to think about any of it—unless you want to.


### **What’s Next?**

The next step is to skip empty iframes entirely. If an frame doesn’t have meaningful content, there’s no reason to waste time indexing it.

But for now, we’re just excited that you no longer have to worry about what kitchen your ingredients are in. Stagehand just **lets you cook**.

**If you’ve been waiting for iframe support—this is it.** 

### Footnotes

1. Managing "contexts" is essentially managing the environment or scope in which browser commands run. In CDP, a context usually refers to an individual browsing context such as a specific webpage or iframe, each requiring its own unique CDP session to control it independently. When switching between Playwright frames, Playwright abstracts this complexity by automatically switching contexts behind the scenes. However, Playwright does not directly provide the ability to send CDP commands that are scoped to a frame. Which means you lose Playwright's automated context handling, forcing you to manually track each individual session context for commands to reach the correct iframe.
2. The Chrome DevTools Protocol (CDP) is Chrome’s remote-debugging API.  It exposes the same low-level hooks that power the DevTools UI, but over a public, JSON-RPC API. This allows external programs to inspect, control, and automate Chrome browsers directly. Playwright itself uses CDP internally when interacting with Chromium-based browsers.

Parsing iframes in browser automations just got WAY easier. Discover how Stagehand’s latest update enables seamless AI-enabled actions and extractions across deeply nested iframes—no manual selector wrangling required. Available June 17.

Taming iframes: A Stagehand Update

Lindsay Gilson

## Challenge: Building reliable web intelligence at scale

Vercel provides the developer tools and cloud infrastructure to build, scale, and secure a faster, more personalized web. Vercel also owns and maintains Next.js, the React framework for building web applications.

Vercel needs to understand the technical landscape of the web. Not just their own customers, but every major website—from funded startups to e-commerce giants. They wanted to track technology adoption, monitor performance metrics, and identify business opportunities in real-time.

Their initial approach hit major roadblocks:

- **Legacy tools were unreliable**: Puppeteer and similar libraries were brittle and error-prone at scale
- **CDN challenges blocked access**: Many sites were inaccessible due to bot detection and security measures
- **Data quality issues**: Existing services like BuiltWith missed critical information
- **Limited parallelization**: Couldn't crawl enough sites fast enough to get timely intelligence

> **"We tried to build this in-house with Puppeteer and all that. There are lots of challenges. Legacy libraries are brittle. We run into errors," explains Abhi Sivasailam, VP of Data.**

## Solution: Browserbase powers Vercel's web intelligence engine

Vercel built one of the most sophisticated internal tools out there to scale knowledge and revenue, internally named **Prism.** This comprehensive web intelligence system uses Browserbase to crawl the entire "Vercel-verse" and beyond. 

Prism tracks all domains hosted on Vercel, top websites from [Google’s Crux database](https://developer.chrome.com/docs/crux), all funded startups, and many ecommerce sites. 

Browserbase plays a few key roles in making this possible:

- **Not your typical scraping data**: Vercel isn’t just looking at site content, they need the header, the body, and the window itself, which requires a browser like Browserbase.
- **CDN bypass capabilities**: Many important sites and data points live in a CDN protected site. Browserbase’s Advanced Stealth feature overcomes the CDN challenge to include those sites in the data set.
- **Massive parallelization**: "If you're going to crawl this many domains, you need to be able to move quickly.” Browserbase allows Vercel to run thousands of browsers at one time as well as in the background and while you sleep.

## Result: Real-time revenue intelligence

The impact of this system is truly impressive.

### A custom churn warning system ⚠️

This program powers the revenue engine! Vercel uses this data to define Sales books of business, do propensity modeling and forecasting, and drive new pipeline. This is also key for retention! By monitoring both production and staging sites, Vercel can predict customer churn before it happens. 

> **"We can see for Vercel customers both staging sites and production sites. If a customer is changing technologies on a staging site, we can identify that and actually do win-backs on people we've identified are about to churn."**
> 

### New: A ship velocity index 🚀

Prism powers a daily Slack channel that tracks real-time technology adoption, like who is upgrading Next.js. With this data, Vercel created a unique "ship velocity index" that analyzes website code changes to determine how fast companies are shipping updates. 

> **"We can see whether the code is changing and answer the question, how fast is the company shipping?"**
> 

## Becoming the new web intelligence standard

There are no plans yet, but Vercel is considering making Prism public, potentially becoming "the new HTTP Archive" as the original Google project winds down. With Browserbase handling the infrastructure complexity, Vercel can focus on extracting valuable insights from this web data.

> **"It's good to have someone reliable handling the browser management and CDN challenges so we can focus on the intelligence layer," Sivasailam notes.**
> 

---

**Ready to build your own web intelligence system?** Join companies like Vercel who are transforming how they use the web to drive business impact. 

[Get started with Browserbase →](https://browserbase.com/)

Vercel uses Browserbase to crawl millions of websites, powering their revenue engine and customer retention strategy.

How Vercel built a real-time web intelligence system with Browserbase

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

## 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?"

The Browser Blog

Building the Future of Web Automation

Building the Future of Web Automation

Read Article

Introducing Director: Web Automation for Everyone

Read Article

How Live View Became Convergence's Secret Weapon

Read Article

5 Hours to 15 Minutes: How Benny Eliminated Automation Maintenance Overhead

Read Article

Introducing the Stagehand API

Read Article

How Browser Infrastructure Became Chronicle Legal's Competitive Moat

Read Article

Taming iframes: A Stagehand Update

Read Article

How Vercel built a real-time web intelligence system with Browserbase

Read Article

Organizations are coming June 4th

Read Article

Unit-testing AI Agents in the Browser

Read Article