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

Kyle Jeong

Sigfrido Narváez

While APIs deliver clean, structured data on a silver platter, the most valuable insights for AI applications often hide in the messy, unstructured corners of the web. AI's potential is immense, and many organizations face a significant challenge: their existing data infrastructure isn't ready for the scale needed by AI. The web is a vast ocean of data, and \~80% of it is unstructured. 

But what if you could reliably automate web interactions, extract complex data, and seamlessly integrate it into a database that offers a variety of query and search methods? This is where the powerful combination of Stagehand (by Browserbase) and MongoDB Atlas redefines what's possible for building AI applications.


![Stagehand-MongoDB-Diagram](https://cdn.sanity.io/images/v773ixxh/staging/7f57877417ca2f3a3cc3d559d067f9941bcac8cd-3450x1276.jpg)


Fig. 1- Stagehand and MongoDB Atlas: Seamlessly automating web data collection and AI-ready integration.

### **Stagehand: An SDK for developers to write automations with natural language**

The browser is a powerful tool for collecting data, but it's hard to control and scale. Traditional browser automation tools like Playwright, Puppeteer, and Selenium often force developers to write fragile code that breaks with even slight UI changes on a website. This makes maintaining scripts on live websites a significant pain point. Stagehand, however, is designed specifically for the AI era.

**Stagehand allows you to automate browsers using a combination of natural language and code**. It's built to be more reliable and adaptable than legacy frameworks, enhancing Playwright's determinism with large language models (LLMs) to account for page changes and volatility. This means you can write code once, and it adapts to that website if it changes.

Key capabilities of Stagehand include:

* **Reading and Interacting with Page Content:** Stagehand can read page content by parsing the DOM using accessibility trees, interact with, and continue to work even when the page changes.  
* **Natural Language Operations:** You can use natural language to extract data or instruct the browser to take actions. For instance, `page.extract("the price of the first cookie")` or `page.act("add the first cookie to cart")`.  
* **Agentic Workflows:** Stagehand allows you to use a simple agent to automate complex workflows with commands like stagehand.`agent.execute("complete checkout")` or stagehand.`agent.execute("Extract the top contributor's username")`.  
* **Full Control:** By extending the `page` and `context` objects from Playwright, Stagehand gives developers full control over the browser session, allowing for deterministic and repeatable automation while being resilient to unpredictable DOM changes.  
* **Performance-Oriented:**  Traditionally, developers would inspect the DOM manually, right-click elements, test CSS or XPath selectors in the console, and tweak them repeatedly to get automation working using the browser’s DevTools, such as the example below to select a button nested in div’s.   
  `await page.click('div.container > div:nth-child(3) button.primary');`  
  With Stagehand, those selectors are automatically inferred and stabilized, so you can focus on logic instead of fragile DOM paths.

For scaled, production deployments, Stagehand works seamlessly with [Browserbase](https://browserbase.com), allowing you to launch hundreds of browsers at once through an API, with  advanced features like session replay, prompt observability, and captcha solving.

### **MongoDB Atlas: The AI-ready data foundation**

Once Stagehand has done its work, gathering dynamic web content and insights, you need a robust, flexible, and scalable database to store, process, and make sense of this data for your AI applications. This is where MongoDB Atlas shines as the ideal data foundation.

MongoDB Atlas is built to handle today's need for flexible, real-time data processing, unlike traditional databases that are rigid and not designed for an AI-first world.

Here's how MongoDB Atlas becomes the memory and content hub for Stagehand's extracted data:

* **Flexible document model:** Stagehand can extract highly diverse information from websites—from product details and customer reviews to financial reports and real estate listings. MongoDB's flexible document model mirrors the way developers structure data in their code, making it a natural fit for complex, semi-structured, and constantly evolving web data. It eliminates the need for cumbersome schema “day 1” definitions and “day 2” migrations, which are a constant bottleneck in relational databases.

* **Native vector search:** A significant blind spot in traditional data analysis is the vast amount of semi-structured data. MongoDB Atlas addresses this by enabling modern vector search workflows. With Stagehand, you can define the structure in every extract call, catering to a variety of concepts—like product reviews, customer support transcripts, or even images from visually rich documents. Once scraped, they can be vectorized via embedding models (such as Voyage AI's [`voyage-3-large`](https://blog.voyageai.com/2025/01/07/voyage-3-large/)) and ingested directly into MongoDB Atlas. Storing these vector embeddings *next to the original text chunks* along with semi-structured data allows for native semantic search queries directly inside the database, reducing system complexity, development and testing time, and enabling low-latency results.

* **Support for agentic AI architectures:** AI agents often require dynamic evaluation criteria and the ability to enrich feature sets based on diverse data. MongoDB Atlas is uniquely suited to store dynamic criteria as flexible JSON documents and serves as the ideal foundation for agentic architectures, allowing captured web data to be used to generate new features for machine learning models without requiring schema redesigns. Checkout another blog post defining [7 Practical Design Patterns for Agentic Systems](https://www.mongodb.com/resources/basics/artificial-intelligence/agentic-systems).

* **Massive scalability:** Whether Stagehand is scraping millions of product listings or billions of clinical data points, MongoDB Atlas's distributed architecture and flexible schema simplify scaling, handling unpredictable workloads and massive data volumes effortlessly. Companies like [Ubuy](https://www.mongodb.com/company/blog/innovation/ubuy-scales-ecommerce-globally-unlocks-ai-with-mongodb) manage over 300 million products and 150 million annual searches, while [SHARE NOW](https://www.mongodb.com/solutions/customer-case-studies/share-now) handles **2 TB of IoT data per day**, all powered by MongoDB Atlas. Additionally, Browserbase enabled [Structify](https://www.browserbase.com/website/blog/case-study-structify) to eliminate gigabytes of RAM usage, bringing memory consumption on their production web servers down to virtually zero, and can support several thousand concurrent browser sessions, allowing them to scrape tens of thousands of websites in a single campaign with ease.

### **The powerful synergy: Stagehand \+ MongoDB Atlas in action**


![](https://cdn.sanity.io/images/v773ixxh/staging/4a372db6d9815fe687957ace63c421b0ac444cfd-1600x1138.png)

Fig. 2 \- Data flow: From web automation via Stagehand to scalable AI processing in MongoDB Atlas.

Imagine the possibilities when Stagehand reliably harvests information from the web, and MongoDB Atlas makes that data immediately actionable for AI:

* **Customer engagement & product discovery:** Stagehand can extract vast amounts of customer reviews and product information from various e-commerce platforms. MongoDB Atlas stores this data as both operational data and vector embeddings, enabling AI-driven recommendations and intent-driven product discovery, as seen with Ubuy, reducing search times from seconds to milliseconds, but still providing traditional query and insights over data as required by human consumers, enterprise systems and external partners and consumers

* **Real-time market and financial intelligence:** Stagehand can be programmed to extract live financial news, market trends, or competitive pricing data. This real-time stream can be fed into MongoDB Atlas Stream Processing for immediate analysis, enabling dynamic pricing models or allowing financial analysts to sift through dense reports with AI-powered multimodal search for specific trends.

* **Enhanced content curation and recommendation:** For media companies, Stagehand can gather articles, reports, and visual content from diverse sources. MongoDB Atlas, with its vector search and multimodal capabilities, allows for a hybrid search experience, blending keyword precision with AI-driven discovery, delivering hyper-relevant recommendations instantly, much like the [Financial Times](https://www.mongodb.com/solutions/customer-case-studies/ft)' solution.

* **Next-gen inventory classification:** By using Stagehand to collect qualitative metrics from product reviews or social media posts (e.g., customer expectations, re-purchase probability), this unstructured data can be vectorized and integrated into MongoDB Atlas. AI agents can then use this enriched dataset to dynamically classify inventory, transforming reactive inventory management into predictive and customer-centric decision-making.


By combining Stagehand's robust web data acquisition, MongoDB Atlas's flexible and AI-ready data foundation (including vector search capabilities), and MongoDB's ability to expose this data and its management tools to diverse AI applications and platforms, organizations can create a truly seamless and powerful data pipeline for their AI initiatives. This setup empowers developers and AI agents to access, understand, and leverage web data at an unprecedented scale and efficiency.

Ready to build smarter, adapt faster, and scale more confidently? Explore [Stagehand](https://www.stagehand.dev/) and [Browserbase](https://www.browserbase.com/) for your browser automation needs and connect it with a free MongoDB Atlas cluster to power your next AI application – get started with the [MongoDB \+ Stagehand integration on GitHub](https://github.com/browserbase/integrations/blob/main/examples/integrations/mongodb).

Discover the power of browser automation with Stagehand and MongoDB Atlas. Seamlessly extract complex web data, store it in an AI-ready database, and enable intelligent insights at scale for your next-generation AI applications.

Scalable Automation Starts Here: Meet Stagehand and MongoDB Atlas

Peyton Casper

For AI to be productive, agents need reliable, responsible web access. Browserbase provides web browsing capabilities for some of the largest AI applications. But today, websites can’t tell the difference between a trusted agent and a malicious bot. As a result, even agents doing meaningful work remain limited by defenses built for abuse. The internet needs a better way to distinguish good actors from bad ones.

That’s why we're excited to partner with Cloudflare to support the adoption of [Web Bot Auth](https://developers.cloudflare.com/bots/reference/bot-verification/web-bot-auth/), a critical layer of identity for agents. With Web Bot Auth, Browserbase will be able to assert the good intentions of our customer’s agents in a cryptographically secure way. Think of it like a passport for your AI agent as it browses the web on your behalf. 

Our customers are at the forefront of deploying AI in production for enterprises and consumers around the world. Whether they are automating compliance for financial institutions, improving AI responses with the latest information, or giving agents access to the same applications that human employees use, they are defining what AI can achieve in practice.

It has become increasingly clear that a key challenge holding back more complex workflows is Identity.

## The Problem

In the past, the predominant use case for bots were crawlers, and there were only a few legitimate organizations with the resources to operate these at scale. AI has radically changed this, enabling more people every day to deploy autonomous agents that perform tasks on their behalf. 

To meet the needs of billions of agents coming online over the next few years, we need a better system. Web Bot Auth is the first among many steps to provide better systems for AI browsing on your behalf

## What is Web Bot Auth?

Think of Web Bot Auth as like giving your agent a verified passport. When Browserbase “issues” this passport, it's equipping the agent with a secure cryptographic signature that acts like a proof of identity. Just as a real passport shows who you are and lets you travel internationally, this digital version proves the agent is legitimate and allowed to “travel” across websites.

![](https://cdn.sanity.io/images/v773ixxh/staging/f33306c0c1dfee0c1502c0d094526952d3bfa361-2828x1840.png)

When the agent arrives at a site, it presents its passport. The website (and likely its anti-bot providers) checks the signature, confirms it's from a trusted source, then lets the agent through. It's a clear and elegant way for websites to know who they’re letting in, without trusting just IPs or plain user-agent strings.

However, just like a passport, this identity is only as useful as the number of trusted partnerships that accept it and are able to validate it. At Browserbase, it’s our role to continue to develop these partnerships to allow our customer to reliably access the web.

## What's Next

Right now, we are actively working with Cloudflare, pilot customers, and other leading anti-bot providers to expand web access for AI. Browserbase is already the leading browser infrastructure provider for AI with good intent and these early partnerships are proof of that. We want our partners and customers to know that when they see an AI with a Browserbase Identity appear on their website, that it represents a trustworthy human, with an agent acting on their behalf.

<custom-cta text="Contact the Browserbase Identity team for access" button_text="Apply" button_link="https://www.browserbase.com/contact-web-bot-auth"></custom-cta>

For AI to be productive, agents need reliable, responsible web access. Browserbase provides web browsing capabilities for some of the largest AI applications. But today, websites can’t tell the difference between a trusted agent and a malicious bot. As a result, even agents doing meaningful work remain limited by defenses built for abuse. The internet needs a better way to distinguish good actors from bad ones.

Cloudflare & Browserbase: Pioneering Identity for AI Agents

Derek Meegan

Browserbase began with a simple yet bold vision: the world needed a new kind of browser specifically designed for automated, AI-driven interactions. In his [founding memo](https://memos.hawkhill.ventures/p/an-internet-browser-for-ai), CEO Paul Klein IV questioned why we were still building web infrastructure for humans when almost half of internet traffic is generated by bots. Combined with the explosion of Large Language Models (LLMs) and autonomous agents, it was clear that the browser needed a fundamental rethinking.

This insight sparked the creation of what would become our core offering: a platform that makes accessing cloud-based browser infrastructure as simple as an API call.

Much like self-driving cars were built to navigate roads originally designed for humans, Browserbase serves as the adapter that enables automated agents to seamlessly navigate the internet. We provide dedicated browsing infrastructure for your agents and automations, an approach that fundamentally differs from consumer-oriented browsers. Our browsers do not live on your device and do not collect your data. Browserbase runs in secure, isolated execution environments where customer data is never shared, sold, or used as training material for third-party AI models.

Browserbase enables developers to effortlessly launch tens, hundreds, or even thousands of browsers simultaneously. Traditionally, managing such infrastructure has been notoriously complex, fragile, and expensive. Without these obstacles, developers can concentrate on core business logic instead of browser configuration and maintenance. 

Spinning up a browser is as easy as:
```javascript
const bb = new Browserbase({ 
	apiKey: process.env.BROWSERBASE_API_KEY 
});

const session = await bb.sessions.create({ 
	projectId: process.env.BROWSERBASE_PROJECT_ID 
});
```

We, however, recognized that providing robust, trustworthy infrastructure was not enough. Developers also needed intuitive ways for agents to interact seamlessly with the web. Existing frameworks were brittle, hard to use, and often required deep expertise to maintain. These technical hurdles served as fundamental barriers to the broader adoption of web automation. Enter [Stagehand](https://www.stagehand.dev/).

Stagehand bridges the gap between precise, step-by-step web automations and fully autonomous browsing agents. On one end of the spectrum, carefully scripted automations offer granular control, high-speed execution, and avoid costly inference steps. On the other end, fully autonomous agents are flexible, resilient to website changes, and continuously improve as the underlying models advance.

![Browser Automation Continuum](https://cdn.sanity.io/images/v773ixxh/staging/6d60d43f19410a79356d21a7078b3449f9166abf-2402x800.png)

Stagehand balances these approaches by allowing users to define individual web interactions in natural language. Users specify actions like "click the login button" or "type my email address," and Stagehand translates these into actionable browser steps. By decomposing complex automations into natural language steps, Stagehand ensures that each AI-enabled action remains focused on a single, unambiguous objective, improving model reliability and accuracy.

Stagehand also minimizes inference costs through its action caching mechanism. As it executes your commands, Stagehand identifies page elements and caches them for future runs, making automation faster and cheaper over time. When websites change, the framework gracefully falls back to AI and rebuilds its cache without disrupting your automation.

Beyond navigation, Stagehand provides a simple interface to extract structured data from any webpage. You define the desired schema, and it intelligently pulls the information you need, whether it's product details, pricing tables, or complex nested data. 

The result is a complete automation system that transforms web interaction and data extraction into plain English instructions that are self-documenting, instantly understandable by any team member, and resilient to the constant evolution of the web. You write what you want to happen, Stagehand figures out how to do it, and then remembers the solution for next time. Here's what this looks like in practice:

```tsx
// Step 1: Navigate to URL
await page.goto('https://www.nasdaq.com/');

// Step 2: Perform action
await page.act('click the earnings link');

// Step 3: Extract data
const extractedData = await page.extract({
  instruction:
    'extract all companies announcing earnings this week with their symbol, company name, market cap, fiscal quarter ending, consensus EPS forecast, and timing (pre-market or after-hours)',
  schema: z.object({
    companies: z
      .array(
        z.object({
          symbol: z.string().optional(),
          companyName: z.string().optional(),
          marketCap: z.string().optional(),
          fiscalQuarterEnding: z.string().optional(),
          consensusEPSForecast: z.string().optional(),
          timing: z.string().optional(),
        }),
      )
      .optional(),
  }),
});
```

The combination of Browserbase and Stagehand dramatically reduces the friction for developers creating automations or providing web access to their agents. Yet despite these advances, a significant technical barrier remained. The legacy applications and workflows that desperately need automation are often managed by professionals focused on their domain expertise: doctors managing patient systems, accountants navigating financial platforms, and operations teams coordinating across multiple platforms.

This gap became crystal clear when we started receiving calls from non-technical builders trying to implement Browserbase and Stagehand automations but struggling to translate their workflows into code. These conversations sparked an insight: what if you could directly harness the full power of browser automation without writing a single line of code?

Enter [Director](https://www.director.ai/)**.** Director takes the powerful foundation of Browserbase and Stagehand and makes it accessible to everyone. Users describe their high-level tasks, such as "download all invoices from last month" or "update inventory across these three platforms," and Director autonomously generates and executes the necessary Stagehand code. Throughout execution, Director leverages Browserbase to perform the task in real-time, self-correct when encountering obstacles, and adapt its approach until the task is complete. It unlocks web automation for the millions of people who know exactly what they need to automate; and they shouldn’t have to learn to program to make it happen.

![How Director Works](https://cdn.sanity.io/images/v773ixxh/staging/1e08a4d9853e877bfe2dece3e00370b13e617e0d-3633x2307.png)

This completes the vision: Browserbase provides the infrastructure, Stagehand offers the intelligent automation layer, and Director makes it all accessible to anyone who can describe their problem. The technical complexity remains under the hood, but the user experience becomes as simple as having a conversation. The result, however, is not just another developer tool or automation framework. It's a push towards a fundamental shift in how humans interact with the digital systems that increasingly dominate our working lives.

Every day, millions of professionals waste countless hours on operational overhead. When we free professionals from clicking through the same workflows day after day, we create space for creativity, strategic thinking, and the uniquely human work that actually matters. The boring work dies so that the interesting work can flourish.

The internet was built for human consumption, but it’s increasingly navigated by agents on our behalf. Browserbase ensures those agents have the tailored, trusted infrastructure they need. Stagehand gives them the tools to navigate complexity. Director extends that power to everyone, regardless of technical expertise. Together, they form a complete ecosystem for web automation that scales from simple tasks to complex workflows, from individuals to enterprise systems.

We are building a future where Browserbase will be remembered for unlocking capabilities that AI alone could not reach. A future where the friction between human intent and digital execution disappears entirely. Where describing what you want is enough to make it happen, and the only limit to automation is your ability to imagine what's possible.

If you’re interested in building the future of web automation with us, [we’re hiring](https://www.browserbase.com/careers).

The browser was built for humans, but half the internet is bots. Browserbase reimagines the browser for AI, providing cloud infrastructure that powers seamless automation at scale. Paired with Stagehand’s natural language automation and Director’s no-code interface, it transforms web interaction into plain English instructions. This isn’t just another dev tool; it’s a new foundation for how humans and AI work online.

What does Browserbase actually do?

Dallas Young

The promise of AI agents is captivating. They are hailed as the next frontier in automation, capable of autonomously navigating websites, filling out forms, scraping data, and completing complex, multi-step processes without human involvement. The demos are slick and the conference talks are inspiring, but the reality for anyone building them in production is a daily battle against a single hard truth:

**The web was built for humans, not for machines**.

The answer is bulletproof browser automation, not merely smarter scripts.

It’s about building a system that always completes its mission, survives the chaos of the web, adapts when things change, and picks up exactly where it left off after something breaks. That’s what happens when you combine Browserbase, a platform for AI-powered browser automation, with Temporal, the industry standard for Durable Execution.

## The Brittle Reality of Web Automation

Meet an engineer tasked with building a web automation workflow. Her goal: complete a complex, multi-page job application on an HR portal. This is a perfect use case for web automation because the portal doesn’t have a public API, and the process involves filling out multiple forms, handling pop-ups, and navigating a multi-step user flow, all of which require a real browser.


![](https://cdn.sanity.io/images/v773ixxh/staging/9775945aa1cff011d45f8d56853ecba3d83d82cd-1508x1084.png)
<br>

She starts with a traditional automation script. It relies on a brittle selector to click the "submit" button.

```javascript
// Traditional Playwright Click
await page.locator('.submit-btn').click();

```

The script works until the next week, when the HR portal's developers change the button's class name from "`submit-btn`" to "`btn-primary`". Her automation script grinds to a halt, forcing her to spend a frustrating afternoon debugging and fixing broken scripts rather than moving on to higher-value work.

Even worse, on a different attempt, a network blip occurs during a crucial data extraction step, causing the entire workflow to crash. All progress is lost, forcing her to start over from the beginning, wasting both time and compute resources. This cycle of “fixing broken scripts” and handling unexpected failures is the reality of traditional web automation.

## An unbreakable foundation: Browserbase and Temporal

This is where [Browserbase](https://browserbase.com) and [Temporal](https://temporal.io/) come to the rescue. Instead of building fragile scripts, she uses Browserbase and its open-source AI browser automation SDK, [Stagehand](https://stagehand.dev), to create an intelligent, self-healing automation. Stagehand uses large language models to understand and interact with web elements semantically, so she can write:

```javascript
// Stagehand Act Call
await stagehand.page.act("click the submit button");
```

Stagehand understands her intent and finds the correct button, even if the underlying HTML or CSS changes. This makes her script resilient to website changes, significantly reducing maintenance overhead.

But what about the network failures and browser crashes? This is where Temporal provides the durability layer. Temporal is a Durable Execution platform that guarantees her code will run to completion, no matter what failures occur. It works by:

* **Persisting state:** Temporal automatically saves the state of her Workflow after every step so if a failure occurs, it can resume from the exact point where it left off. This is critical for long-running processes that would otherwise lose all progress across network interruptions, service restarts, or deployments.  
* **Intelligent retries:** She can declaratively define [Retry Policies](https://docs.temporal.io/encyclopedia/retry-policies) for the various steps in the automation workflow, and Temporal will automatically manage retries for transient failures like network issues or timeouts.  
* **Ensuring completion:** Temporal ensures the entire multi-step process completes successfully, even if individual browser sessions crash.

She achieves this by wrapping the failure-prone portions of the Workflow in [Temporal Activities](https://docs.temporal.io/activities). This simple but powerful pattern ensures that every single browser interaction, whether it's filling out a form on page one or clicking 'Submit' on page six of the job application, is durable and retryable. If the browser session dies or the website hangs, the Activity will simply retry that specific step, picking up right where it left off and reusing the existing Browserbase session thanks to the idempotent design. This transforms a fragile, manual-fix process into a reliable, self-healing automation.
### **From basic code to bulletproof production**

In our Browserbase Integrations [GitHub repository](https://github.com/browserbase/integrations/tree/master/examples/integrations/temporal), you'll find a simple, getting-started code sample that demonstrates this powerful combination: a resilient search workflow. It's a foundational example that shows how to encapsulate each step of a multi-step browser task in a durable Temporal Activity with automatic retry logic. This showcases the core principles of the partnership:

* **Atomic Activities**: Each step performs a single, well-defined task. For example,  
  `initializeBrowser` creates a browser session, and `executeSearch` types a query and submits the search. If one fails, only that specific step needs to be retried, not the entire Workflow, making Workflows efficient, easier to debug, and more flexible.

* **Idempotent design**: For safe automatic retries, Activities must be idempotent, meaning they can be called multiple times without causing unintended side effects. For instance, a `cleanupBrowser` Activity should be able to close open browser sessions, and gracefully handle sessions that may already be closed.

The Temporal Workflow orchestrates these atomic Activities, defining the sequence of operations and applying tailored Retry Policies to each one. For example, the `extractSearchResults` Activity, which is most susceptible to website changes or network issues, is configured with more aggressive retries. This gives the developer granular control over how the system handles different types of failures.

Below you will see two steps of the Workflow, `navigateToSearchPage` and `executeSearch`, in both the Temporal UI and the Browserbase console.


![](https://cdn.sanity.io/images/v773ixxh/staging/d336ed7e2575b4f056c9b7c2757d472182c8802b-1354x486.png)

![](https://cdn.sanity.io/images/v773ixxh/staging/d293a34b7e38a39550a8f6aac8a49eb9155e26e1-1354x486.png)

Once the Workflow completes, you will see the top 3 search results for our initial question, “*How would you classify a Liger?”*


![](https://cdn.sanity.io/images/v773ixxh/staging/5517ceb854612250edec591d399212c5e7389cfa-2246x1970.png)


While the code sample focuses on a simple Brave search, it's easy to see how this same architectural pattern can be scaled to solve more ambitious use cases like:

* **Large-scale data collection:** Extracting structured data from thousands to millions of dynamic websites with high success rates, automatically adapting to layout changes.

* **Complex fintech automation:** Automating multi-page form submissions for critical tasks such as KYC (Know Your Customer) checks or loan applications on banking websites.

* **AI-agent workflow orchestration** Building multi-step AI agents that perform tasks across different platforms. For example: an agent that researches market trends, logs into a CMS to draft a blog post, and then schedules it on a social media platform.

The future of bulletproof web automation is here thanks to Browserbase and Temporal. Engineering teams can finally move beyond fixing fragile scripts and focus on building long-running, critical Workflows that truly drive business value. When your automation adapts to website changes automatically, you can monitor more sources with greater confidence.

Ready to build web automations that never fail? Dive into the full, runnable code example we've discussed by visiting the [Temporal Code Exchange](https://temporal.io/code-exchange/temporal-stagehand-integration), or review the integration documentation. You'll find detailed instructions on setting up your environment, configuring API keys, and running the resilient search Workflow to see Temporal and Browserbase in action.

---

* **Get started:** Learn more about building your first durable Workflow with the [Temporal Documentation](https://docs.temporal.io/) and the [Browserbase Quickstart](https://docs.browserbase.com/introduction/what-is-browserbase).  
* **Dive into the code:** Review the [Integration documentation](https://docs.browserbase.com/integrations/temporal/introduction) and [runnable code example](https://github.com/browserbase/integrations/tree/master/examples/integrations/temporal) on Github.  
* **Need help?** Join the [Temporal Community Slack](https://temporal.io/slack) and the [Stagehand Slack](https://stagehand-dev.slack.com/join/shared_invite/zt-38c2tuck6-Nvl3~vuTPx7Fm7Qmb7kswQ#/shared-invite/email) to connect with thousands of other developers.




Build reliable web automation systems by combining Browserbase (an AI-powered browser automation platform) with Temporal (a durable execution platform).

The unbreakable web: From fragile scripts to bulletproof Workflows

## Good Bots vs. Bad Bots


Billions of agents will be accessing the internet by 2030 representing both legitimate and malicious intent. On one hand, hundreds of enterprises use Browserbase to automate existing human tasks that would have been impossible a few years ago. On the other hand, there are thousands of bad actors using AI and “bad bots” to commit fraud and violate copyright laws.

The simple fact is that we have already opened pandora’s box. AI agents are an entity that operate on behalf of enterprises and individuals to perform tasks that would otherwise be performed by humans. This might be searching for information or automating compliance for financial institutions.

If the internet is going to remain open, then agents are going to need to self identify. However, they are only going to do this if they aren’t going to be indiscriminately harmed for doing so. Browserbase, Perplexity and Cloudflare all want to prevent bot farms, hackers from North Korea and flagrant copyright abuse from destroying the internet. To do that, the trust model needs to change.

## The Problem

In the past, the relationship between users and anti-bot providers was transparent. But now, the web is changing, as individuals are delegating their tasks to AI agents that use the web to work on their behalf. Agent users, anti-bot providers and website owners need to partner together to identify and enable legitimate use cases while punishing abuse. We need to look no further than the copyright challenges presented by Reddit for an example of how this could work.



![](https://cdn.sanity.io/images/v773ixxh/staging/1b89fbda22beca76877073b8a03679522bde33d9-1266x726.png)



In the relationship structure above, all parties are incentivized to work together to make Reddit safe as it emerged as a common good. If we overlay this relationship model onto the AI agent discourse, we’ll see that a similar system emerges. 


![](https://cdn.sanity.io/images/v773ixxh/staging/bb69072e82376a50968afa5c42b84a98a9c7f0ea-1260x692.png)


## The Future

Enabling agent providers (Browserbase, Perplexity), Anti-bot companies (Cloudflare, Google reCAPTCHA) and website owners to work hand in hand is not a simple task. However, it is absolutely critical for providing equal opportunities to all AI agent developers with a trust first model that once abused, restricts access.

The open question, is how we can enable agent authorization across the internet. Agents should be trusted but monitored for abuse and malicious activity. If detected, they should automatically be restricted with additional mechanisms for website owners to notify and restrict agents owners on their own. This builds on top of a strong identity model and allows all parties to bring their own tools to the table.

At Browserbase, we are tackling this problem head on and have already engaged in partnership discussions with leading anti-bot providers and [authentication provider like Stytch](https://stytch.com/blog/introducing-is-agent/).

Meanwhile, we are tracking proposals advancing through IETF to enable agent identity via [Web Bot Auth](https://datatracker.ietf.org/doc/html/draft-meunier-web-bot-auth-architecture) with multiple companies like Cloudflare and OpenAI actively implementing at scale.

Browserbase is the best-in-class browser infrastructure for AI with good intent to incorporate the web into their workflows. 

We seek to work with website owners, anti-bot companies and agent developers to ensure malicious agents get blocked and legitimate agents are able to access the internet freely. 

If you want to partner with Browserbase, we’d love to hear from you. Email us at trust@browserbase.com

As billions of AI agents begin to access the internet, a new trust model is urgently needed. Browserbase breaks down how agent owners, website operators, and anti-bot providers can collaborate to ensure legitimate automation thrives—while abuse is swiftly shut down.

Billions of agents, one internet: Separating trust from threat

Beatriz Go

**E-commerce tax platform eliminates manual work with Browserbase's AI-powered browser automation**

-----

[Numeral](https://www.numeralhq.com) has transformed sales tax compliance for e-commerce businesses by automating the tedious process of managing state tax portals. Using Browserbase and Stagehand, Numeral is eliminating days of manual scripting work while building reliable automation across dozens of different government systems. They’re only just beginning.

### **The sales tax challenge**

E-commerce businesses selling across multiple states face a compliance nightmare. Each state has different tax rules, rates, and filing requirements. Companies must maintain active registrations in every state where they have tax obligations, file returns on varying schedules, and navigate dozens of unique government portals.

Before Numeral, businesses relied on accountants to manually handle each state's requirements - or worse, didn't realize they had compliance issues at all. Those who tried to stay compliant spent hours logging into different portals, checking for updates, and filing returns.

"Sales tax can be different for different items, and different states have different rules and regulations," explains Watson, an engineer from the Numeral team. "We're helping companies work through all that with a white-glove service that keeps their compliance to just five minutes a month."

### **Numeral's automation challenge**

Numeral set out to automate the entire sales tax compliance workflow. Each state has its own unique portal with different login flows, two-factor authentication methods, and filing processes.

The Numeral team needed to:

* Verify client credentials **across 48 different state portals**
* Handle diverse two-factor authentication systems
* Add Numeral as an authorized user for notifications
* Automate tax filing submissions

Initially, they explored building these automations with Playwright scripts. But the complexity quickly became apparent - each portal would require extensive custom code to handle its unique quirks and authentication flows.

### **Enter → Browserbase and Stagehand**

Browserbase's AI-powered automation changed everything. Instead of writing complex scripts for each state portal, Numeral could use natural language prompts to navigate these systems.

> "Having the AI capabilities now with Stagehand definitely made it a lot easier. We're writing less code to achieve more," Watson notes. "Creating the Browserbase and Stagehand automation saved days worth of work that would have been manual Playwright scripting."

The migration proved transformative:
* **Natural language automation**: Instead of specifying DOM selectors, Numeral uses prompts to navigate portals
* **Easier maintenance**: AI adapts to DOM changes without code updates
* **Built-in resilience**: Handles authentication flows and portal variations automatically

### **Why Browserbase stood out**

While evaluating options, Browserbase distinguished itself through exceptional support and ease of implementation.

"The excellent customer service and how responsive you guys were to any issues really made you stand out. We had an issue come up late Friday night and you resolved it that evening."

The combination of powerful technology and responsive support sealed the deal. Numeral could focus on building their product instead of wrestling with browser infrastructure.

### **Scaling tax automation nationwide**

Today, Numeral is systematically automating state tax portals across the country. They've started with implementations and will be expanding rapidly.

### **The impact so far:**

* **Development time saved**: Days of manual scripting work eliminated per portal
* **Maintenance simplified**: AI-powered automation adapts to portal changes
* **Team focus**: Engineers building product features instead of maintaining scripts
* **Customer experience**: Reliable automation replacing error-prone manual processes

"We're hoping to have a bunch of it automated by the end of this year. It's super promising right now," Watson shares.

Numeral's success demonstrates how modern browser automation can tackle even the most complex, regulated workflows. By choosing Browserbase, they transformed a manual process into reliable automation that scales.


-----

Ready to automate your tax compliance workflows? Start with [Browserbase](https://www.browserbase.com/sign-up)

How startup Numeral uses Browserbase to automate the sales tax compliance process across dozens of government websites for all types of businesses. 

How Numeral is Automating Sales Tax Compliance

Ash Rathie

Sophie Chance

### **But first, what is Browserbase?**


-----



**Simply put, Browserbase lets you run code-controlled or AI-controlled web browsers in the cloud.**


It’s a browser infrastructure platform, which means we run your fleet of browsers so that you don’t have to deal with all that infra or compute. Whether it’s AI agents or traditional automations, we also make monitoring your fleet easy. It has several superpowers built-in to handle all the thorns that teams usually face when automating the open web:


![](https://cdn.sanity.io/images/v773ixxh/staging/8e1319312c7f274911b88087b8b8cfcd28617d45-1920x1080.png)

In short, Browserbase shines when you need **repeatable tasks at scale**, hundreds or thousands of sessions your system can’t handle. 

To make it easy to build AI Web Agents, we also built **[Stagehand](https://www.stagehand.dev/)**. You can think of it as an evolution of the traditional automation frameworks (Playwright, Puppeteer, Selenium). Developers use Stagehand’s agent(), act(), extract(), and observe() primitives to imbue their scripts with LLM intelligence.

## What are people building with Browserbase + Stagehand?
Our customers and users have been building TONS of amazing things with Browserbase and Stagehand. We noticed 3 common themes…


**1. Build an AI agent that surfs the web**

- 1.1 Turn webpages into structured datasets (Structify)
- 1.2 Automatically sniff out new competitors
- 1.3 Faster merchant onboarding for food-stamp promotions (Benny)
- 1.4 Find a dinner spot equidistant from your friends
- 1.5 Get real-time background research on sales leads (Aomni)
- 1.6 Serve consumer agents with human-in-the-loop redundancy Convergence)


**2. Automate a tedious process or workflow**

- 2.1 Reach out to waitlisted users with personalized copy
- 2.2 Never forget to submit expense reports
- 2.3 Handle tedious sales-tax compliance with agents (Numeral)
- 2.4 Run due diligence on financial compliance for prospects (Parcha)
- 2.5 Build agents in HIPAA-sensitive domains (Commure)
- 2.6 Automatically verify HR compliance in hospitals
- 2.7 Automatically process incoming RFPs


**3. Web scraping**

- 3.1 Unearth data insights while avoiding rate limits and CDN defenses (Vercel)
- 3.2 Gauge investment quality of new real-estate listings
- 3.3 Eliminate browser instance scaling issues from spiky demand (PromptLoop)
- 3.4 Gather specific data to train a specialized model (Coframe)
- 3.5 Extract product reviews at scale
- 3.6 Automatically gather evidence for disability law firms (Chronicle Legal)
 

-----


##  1. Build an AI agent that surfs the web
Need your agent to click, fill, or fetch like a human? Browserbase provides the disposable, stealth-ready browsers; Stagehand injects just enough AI to keep the flow alive when pages change. Together they turn “open a tab and do X” into a single API call, so teams can bolt real web interaction onto any model without babysitting a browser farm.


**Turn webpages into structured datasets ([Structify](https://www.browserbase.com/website/blog/case-study-structify)).**
Structify equips enterprises with AI crawlers that turn raw webpages into neatly structured data. Every crawl request triggers concurrent Browserbase sessions routed through rotating residential IPs; Stagehand extracts tables, prices, or SKU details that are then written to a central store. After moving off a self-hosted grid, Structify cut server RAM from gigabytes to almost zero and routinely scrapes **tens of thousands of sites per run** without worrying about fingerprinting or Kubernetes scaling.


**Automatically sniff out new competitors.**
A small SaaS founder schedules a Stagehand job at 07:00. The agent opens Product Hunt, Hacker News, and Crunchbase through Browserbase’s stealth browsers. On Product Hunt and Hacker News, it analyzes new startups for any overlap in mission or customers. On crunchbase, it looks through funding events posted in the last 24 hours. Results are compiled into a Markdown summary and sent to Slack with a link to the session replay for any item that needs double-checking. One script, no self-hosted browsers, and the founder can keep an eye on the competitive landscape without hours of research.


**Faster Merchant On-Boarding for Food-Stamp Promotions ([Benny](https://www.browserbase.com/website/blog/case-study-benny)).**
Benny lets SNAP shoppers link their Walmart, Kroger, and H-E-B loyalty accounts so the app can pull purchase history and surface brand promotions. Because none of those merchants expose APIs, Benny originally ran hand-rolled Playwright scripts on AWS Lambda, hundreds of fragile flows that broke whenever a login screen or DOM was tweaked. Engineers were losing **4–5 hours a week per script** just on upkeep, and adding a new merchant took up to two weeks. Moving the same logic to Stagehand agents running on Browserbase flipped the math: AI now adapts to layout changes, Browserbase replays cut issue-diagnosis time from 30 minutes to under a minute, and a new retailer can be onboarded in about one day. The shift also avoided a planned hire for a full-time “browser-infra specialist,” letting the team stay focused on financial-services features instead of scraping mechanics.


**Find a dinner spot equidistant from your friends.**
A Stagehand agent takes in each friend’s current location, and queries Google Maps to find restaurants whose travel times differ by no more than ten minutes. It books the reservation via OpenTable and emails the details. Everyone is happy that they skipped the tedious process of searching through 15 restaurants to placate everyone. Live View lets a human step in if two-factor auth appears.


**Get real-time background research on sales leads ([Aomni](https://www.browserbase.com/website/blog/case-study-aomni)).**
When an account executive enters a lead into Aomni, the backend kicks off a mini “crawl job” that fans out across the web: home-page, careers, press releases, LinkedIn, funding news, product docs, competitors. Instead of juggling a proxy service or a home-grown Playwright farm, Aomni launches a batch of parallel Browserbase sessions—one API call supplies both the reverse-proxy layer and the headless browser. Those sessions return fully rendered pages in a few seconds, the AI stack extracts ~1k data points, and the user sees a ready-made brief and personalised email draft before the call starts. By folding proxy and browser into a single service, Aomni delivers live, low-latency research at the moment of need and keeps its four-person team focused on AI logic rather than infrastructure plumbing.


**Serve consumer agents with human-in-the-loop redundancy ([Convergence](https://www.browserbase.com/website/blog/case-study-convergence)).**
Convergence ran a consumer assistant app to handle a wide range of tasks—everything from booking a gym class to checking flight prices. Each task starts as a Stagehand script inside Browserbase; if the agent hits MFA or an unexpected prompt, the user receives a Live View URL and can finish the flow in the same session (a key feature that caused them to switch to Browserbase). Using Browserbase eliminated the need to build a custom pool of Playwright workers and, according to their team, saved them from having to dedicate 3-4 engineers just for browser infra.


-----

## 2. Automate a tedious process or workflow
Many business tasks still hide behind dated web portals and multistep forms. By dropping those flows into Stagehand scripts that run on Browserbase, companies replace brittle scripts and nightly chores with hands-off jobs that scale, self-heal, and leave a replay trail for auditors—all while the core product team keeps its focus elsewhere.


**Reach out to waitlisted users with personalized copy.**
When someone joins your product’s early-access list, a Stagehand agent fires up immediately. It opens the prospect’s website and LinkedIn page through Browserbase, identifies industry, funding stage, and recent headlines, then writes a note—“Saw your Series A last month; here’s why we’re a fit”—directly into HubSpot. The entire flow lives in one script, runs in under 60 seconds, and scales to any spike because Browserbase spins up new stealth browsers on demand.


**Run due-diligence on financial compliance for prospects ([Parcha](https://www.browserbase.com/website/blog/case-study-parcha)).**
Parcha’s four-person engineering team helps banks onboard customers by collecting website content, corporate filings, and sanction lists—tasks that once kept analysts busy for an hour per business. With Browserbase’s pooled browsers they open all required sites in parallel, while Stagehand extracts and scores risk signals. The same workflow now runs in about 10 seconds, freeing the small team to focus on AI logic rather than a self-hosted Playwright grid and pushing compliance bottlenecks out of the onboarding flow.


**Build agents in HIPAA-sensitive domains ([Commure](https://www.browserbase.com/website/blog/case-study-commure)).**
Hospitals use Commure’s “Scout” product to watch payer portals for updates, grab PDFs, and reconcile claims. The R&D team needed live URLs for real-time QA, session recordings for audits, and reliable PDF downloads, requirements no other tool met in one package. Moving to Browserbase gave them HIPAA-compliant, managed browsers with those three features out-of-the-box; engineers stopped firefighting an in-house grid and focused on product work. Result: a **20x jump in daily claims processed**, 8,000+ manual hours saved in three months, and confidence that PHI stays secure while bots navigate insurer sites


**Never forget to submit expense reports.** 
Every Friday a Stagehand workflow logs into the finance portal, uploads receipt PDFs from a tagged Gmail label, fills the expense form, and submits for approval. Browserbase session recordings give finance a replay if a claim is questioned, and residential proxies prevent rate-limit issues on shared corporate networks.


**Handle tedious sales-tax compliance with agents.**
E-commerce sellers must log into 50-plus state portals, pass 2FA, file returns, and keep credentials fresh—each site with its own quirks. Numeral swapped days of hand-written Playwright per portal for Stagehand prompts that tell an agent “log in and file this month’s return,” letting Browserbase handle fingerprints, downloads, and residential proxies. Engineers now write far less code, AI adapts when a state shifts its DOM, and the team has begun rolling out automation nationwide, eliminating days of manual scripting for every new portal and keeping compliance work to “five minutes a month” for customers.


**Automatically verify HR compliance in hospitals.**
Hospitals must prove every temp-nurse and travel nurse on shift holds an active licence in the state where they practice. A nightly Stagehand workflow starts at 2 am, spins up 50 parallel Browserbase sessions (one per nursing-board portal), and signs in with stored credentials. Many boards sit behind CAPTCHA or geo-checks, so the script runs with Advanced Stealth enabled and Browserbase’s residential proxies. Inside each site the agent locates the “License Lookup” table, enters the nurse’s number, and scrapes status and expiration dates. If a board quietly reorders columns or swaps IDs, Stagehand’s fallback LLM reroutes the selector, logs the change, and continues—no human patch cycle required. The script writes results to the hospital’s HR Information System, attaches the Browserbase replay URL for audit, and emails compliance if any licence is within 30 days of expiry, all before staff clock in.


**Automatically process incoming RFPs.**
A Stagehand agent watches the “RFP” Gmail label; each time a vendor email lands, it downloads attachments, converts PDFs to text, and appends them to a single Notion page. Procurement gets a consolidated doc by morning, with Browserbase replays available for any attachment that fails OCR. 


-----


## 3. Web Scraping
A lot of times, users need to gather very specific, not easily accessible data. Whether you’re tracking prices across thousands of domains or building a market-intelligence engine, Browserbase supplies headless browsing at cloud scale, complete with rotating residential proxies and advanced anti-bot masking. Render the full DOM, capture screenshots, and fan out to millions of pages—no infrastructure or rate-limit surprises.

**Unearth data insights while avoiding rate limits and CDN defenses ([Vercel](https://www.browserbase.com/blog/case-study-vercel)).**
Vercel built an internal system called Prism to crawl millions of domains—every site hosted on Vercel, top CrUX performers, funded startups, and large e-commerce stores—and turn that data into sales signals. Prism needs headers, full DOM, and the browser window object, which rules out lightweight HTTP scrapers. Browserbase supplies thousands of parallel Chrome sessions plus Advanced Stealth to bypass CDN defenses, letting Vercel refresh its corpus fast enough to power daily Slack alerts: churn-risk flags when a customer tests a rival platform, a “ship-velocity index” that tracks how often companies deploy code, and propensity models that feed the sales pipeline. What was once an unreliable Puppeteer farm is now a revenue engine that crawls the modern web at scale without internal browser-grid maintenance.


**Gauge investment quality of new real-estate listings.** 
An investment fund schedules a Stagehand job to crawl regional MLS sites at 2am. The agent logs in, applies specific filters (ZIP codes, price bands), scrolls through all pages to trigger lazy-loaded cards, and captures address, square footage, and listing agent into a database. Browserbase’s replay links are stored alongside each record so analysts can verify edge cases in a click, and rotating proxies keep the bot beneath MLS traffic thresholds.


**Eliminate browser instance scaling issues from spiky demand ([PromptLoop](https://www.browserbase.com/website/blog/case-study-promptloop)).**
PromptLoop lets go-to-market teams label tens of thousands of company websites in a single job—industry, tech stack, hiring signals—without writing code. The bottleneck was reliable JavaScript rendering under spiky demand: a customer may launch a 100,000-domain analysis that needs answers in hours. Swapping a self-hosted browser tier for Browserbase gave PromptLoop a stable, on-demand layer that spins up thousands of stealth browsers and rotates residential IPs automatically. Success rates for accessible sites climbed from ~87% to over 95%, engineers recovered the DevOps hours once spent debugging ECS scaling failures, and the team now processes an order-of-magnitude more jobs each month while focusing on model quality, not browser plumbing.


**Gather specific data to train a specialized model ([Coframe](https://www.browserbase.com/website/blog/case-study-coframe)).**
Coframe builds an AI system that automatically proposes and A/B-tests new versions of a customer’s hero section, banner, or checkout flow. To train its model, Coframe first needs a big library of live site snippets. With Browserbase, it spins up hundreds of parallel, stealth browsers, loads each target URL, extracts the HTML + CSS that render the section, and feeds the code to its “AI copywriter + designer” pipeline. Jobs that once waited in a slow Playwright queue now finish in minutes, and Coframe’s engineers never touch proxy or CAPTCHA logic—they stay focused on the experimentation engine.


**Extract product reviews at scale.** 
A consumer-analytics startup uses Stagehand prompts to paginate marketplace listings, open each product page, and scrape ratings, price history, and verbatim reviews. Set Browserbase to rotate residential IPs every couple dozen pages. Results stream into a sentiment model; management dashboards refresh hourly without triggering marketplace rate limits.


**Automatically gather evidence for disability law firms ([Chronicle Legal](https://www.browserbase.com/website/blog/case-study-chronicle)).**
Disability attorneys must check the federal ERE portal for new evidence on hundreds—or in large firms, thousands—of active Social-Security cases. Chronicle’s founder first tried a self-hosted Selenium grid but spent hours each week nursing hung containers and scaling capacity. Migrating to Browserbase replaced that brittle setup with managed stealth browsers that spin up on demand and stay compliant with government-site security. Today Chronicle runs 100k+ sessions per month with virtually no downtime, provides replay links so paralegals can verify each scrape, and touts browser reliability as a competitive edge—all without adding DevOps headcount.

### We Didn’t See This Coming 🤯
There are many use cases that we predicted when building Browserbase, but our customers manage to keep surprising us with their creativity:

* **Internal “busy-work” automations**  – Enterprise tooling like Workday are so clunky they take hours of productivity away from an employee every week. With Browserbase, we’ve seen customers automate these wasteful internal tasks away.

* **QA & UX Testing** – Teams spin up an AI agent in Stagehand, tell it “find the contact page,” and watch how many steps it takes. If the bot struggles, that’s an indication that real users would struggle too. Because every session is recorded, product managers can replay the journey and fix navigation dead-ends before real users complain.

* **Synthetic user traffic for analytics demos** – An analytics provider wanted to show their customers predictive usage data. By launching swarms of headless browsers that wander sites like real visitors, they populate engagement graphs without relying on staged data.

The pattern: once a session-recorded, intelligent browser is just an API call away, teams apply it to chores we never imagined when we first built Browserbase.

### Looking Down the Road
We can only speculate but we think in the next 3 years:

* **Consumer use cases explode** – Booking DMV renewals, snagging sneaker drops, disputing credit-card fees. Personal web agents will become as commonplace as password managers.


* **Hybrid systems win (AI + deterministic scripts)** – Pure agentic solutions will continue to be less performant than a hybrid between a deterministic script and intelligent AI decisioning. Stagehand’s act() with caching falls back to the LLM only when the DOM changes, otherwise it uses the proven selectors. We think this concept will continue to prove most effective.


* **Invisible background agents** – Finance ops, partner integrations, even SaaS-to-SaaS interactions will quietly rely on headless browsers to bridge the “no-API” gap. End-users may never know an agent clicked the button for them, but they’ll notice faster outcomes and fewer manual steps.

### So What Will You Build?
Browserbase provides ready-to-use, cloud browsers with stealth, proxies, concurrent sessions, and session recording built in. Run plain Playwright scripts or add LLM intelligence with Stagehand, and scale from one browser to hundreds without running your own grid. Whether you’re building internal automation, a new consumer AI product, automate data entry, or pretty much anything you can think to do on a browser, check out Browserbase and Stagehand.

Teams at Vercel, Perplexity, Commure and more are already shipping products on top of Browserbase!

Play around in [our playground](https://www.browserbase.com/sign-in?redirect=https%3A%2F%2Fwww.browserbase.com%2Fplayground) or book a [demo](https://www.browserbase.com/contact).

Let’s build together. On your mark… get set… GO!! 💥


An overview of the Browserbase product and the many use cases it has.

What can I use Browserbase for?

The browser wars have begun again. But they're not browser wars, they're data wars. OpenAI and every large startup wants control. They want everything that makes you, *you*. Your data. Your access. Your identity. This is not the way.

You need to give your agent a browser. A browser that's separate from your identity. Your agent isn't you - it's acting on your behalf. And that means it shouldn't have as much access as you do. Your AI agent is your delegate, and it doesn't need to live on your laptop.

There are no more browser wars. The browser is a solved problem. Browsers render HTML and CSS faster than we've ever seen before. What it needs are intelligent agents that operate browser-agnostically, working with whatever browser is already in your workflow, acting as an extension of your browser.

Don't give an AI company your data. Give your AI agent your data and let it act on your behalf. An agent that you own, an agent whose logic you control. The large language model is merely a conduit from your data to intelligence back to your systems.

Big companies don't want you to think that. They want you to think that your browser is wrong, the interface is wrong, and the way you do things is wrong. But actually, the way you do things is right. Browsing is fun! I love scrolling on X. I love shopping on Newegg. I love reading the Hacker News comments. This is what makes browsing fun.

But there's a lot of boring browsing. Browsing that I don't want to do. Browsing that I have to do because I have to complete a task that somebody else made me do.

This is the browsing that I want to give to my agent. And I want my agent to be able to access the software I have access to. But big software doesn't want me to have a better software experience. Software companies want me to use their software. They want me to touch their unnecessary buttons. They want me to click on 5 different fields because they were paid to implement that function. They’re scared. Afraid of a future where my AI agent interacts with their software because I don't want to anymore.

This is the red pill. When you let your AI agent act on your behalf, you're freeing yourself from the work you never really wanted to do in the first place. We're letting go of the work that really didn't mean anything to us at all, but created trillions of dollars of market cap for software companies that made a button to upload a file to complete some process on behalf of somebody else.

Software is going to change forever. The people who are innovating are making software that doesn't require you to leave their interface. They're making software with more powerful buttons. Buttons that are expressive. Forms that take in any input you give them. And these buttons will go out and do work on your behalf. This is much more powerful software. We're no longer limited by the bounds of partnerships and integrations but by the bounds of our imagination.

The perfect world doesn't require you to use browsers to do boring work. The perfect world requires you to use browsers for the things you truly love. I ride my bicycle to work because I want to. I don't ride my bicycle to the farm to pick up groceries. Operating with leverage is what makes us human. It's innovation. It moves us forward as a society.

The future of browsing is changing. It doesn't mean websites are going away. It means that people are going to be able to do the browsing they love and spend time doing things they care about. And that’s the future we’re building at Browserbase. If you’d like to come build it with us, my DMs are open.

You need to give your agent a browser. A browser that's separate from your identity. Your agent isn't you—it's acting on your behalf. And that means it shouldn't have as much access as you do. Your AI agent is your delegate, and it doesn't need to live on your laptop.

You should own your browser.

**Healthcare platform transforms manual claims processing into automated workflows, saving 8,000+ hours in three months while maintaining strict compliance standards**


-----


Commure has revolutionized healthcare technology with a comprehensive suite of applications spanning patient engagement, electronic health records, and revenue cycle management. By leveraging Browserbase's HIPAA-compliant managed browser infrastructure, Commure transformed their manual claims reconciliation process into a scalable, automated system that processes 20x more claims daily—all while maintaining the stringent security and compliance standards healthcare demands.

### The problem in healthcare billing

Healthcare providers lose billions annually to inefficient claims processing. After submitting claims to insurance companies, providers must constantly monitor payer portals for updates—checking if claims were approved, partially paid, or denied. This critical but tedious process determines whether providers get paid for their services.

For Commure, this meant teams of billing specialists manually logging into dozens of payer portals daily, checking claim statuses, downloading EOBs (Explanation of Benefits), and updating their systems. With hundreds of claims per provider and multiple insurance companies, the process consumed thousands of hours monthly.

>"When a health system or practice submits a claim, we process and reconcile claims against insurance," explains Ash who runs Commure's Research & Development org. "Health systems hire teams of people to check these portals manually. With virtualized browsers from Browserbase – we’ve built AI agents that do this automatically"

### From manual processes to scalable automation
Commure initially automated this workflow using an in-house setup. While this worked for initial testing, it quickly revealed significant limitations:

- **Scalability Issues**: Managing their own browser grid became increasingly complex as volume grew
- **Maintenance Overhead**: The team spent valuable engineering time maintaining infrastructure instead of building product features.
- **Reliability Concerns**: Self-hosted browsers required constant monitoring and troubleshooting
- **Time Constraints**: As part of the R&D team, building rapidly was key and managing browser infrastructure was time consuming to build and maintain

> "We're building very quickly as part of the R&D team," notes Sai, who leads the automation team. "Having to manage our own grid of browsers didn't seem scalable for us. We wanted to focus on building a product that can scale quickly."

### The 3 Requirements that led them to Browserbase

Commure evaluated multiple browser automation solutions against three critical requirements:

1. **Live URL access** for real-time quality assurance
2. **Session recordings** for post-process verification
3. **Download management** for handling PDFs and EOBs from payer portals

While other solutions met one or two requirements, only Browserbase delivered all three out of the box.

The migration transformed their operations immediately. Instead of managing their own infrastructure, Commure's team could focus entirely on building their Scout automation product. The managed browser infrastructure scaled effortlessly with demand, eliminating capacity planning and infrastructure maintenance - all within a secure, compliant environment.

> "Browserbase is a bit like AWS," explains Ash. "We could build our own infrastructure but Browserbase provides a clean interface and is cost-effective, so the buy versus build math makes sense."

The live URL feature became crucial not just for operational efficiency, but for maintaining security oversight. It enables Commure’s team to monitor automated agents navigating payer portals in real-time, ensures RCM flows are handled appropriately and builds trust in the automation.

>"Precision when working with health data is important to us," Sai explains. "Being able to see in real time what our agent is doing and how it's going into these payer portals to grab information gives us the oversight we need."

It also helps that Browserbase are great partners for developers. 
> "It's very developer friendly," notes Sai. "That's a number one necessity to integrate. The fact that we also requested a feature and it was implemented in a month was quite nice"

### Transforming healthcare operations at scale

The impact of Browserbase extends beyond technical metrics to fundamental business transformation:


- **20x increase in daily claim processing volume** for critical QA workflows
- **8,000+ hours of manual work automated** in just three months
- **Zero infrastructure management** required from the engineering team
- **HIPAA-compliant operations** with BAA ensuring patient data security

As Commure expands their healthcare suite, Browserbase will help with their vision: building automation that frees providers to focus on what matters most - delivering exceptional patient care.

---

Ready to transform your healthcare operations? See how [Browserbase](https://www.browserbase.com/) can power your automation workflows while maintaining compliance and scalability.

The Browser Blog

Building the future of web automation

Building the future of web automation

Read Article

Scalable Automation Starts Here: Meet Stagehand and MongoDB Atlas

Read Article

Cloudflare & Browserbase: Pioneering Identity for AI Agents

Read Article

What does Browserbase actually do?

Read Article

The unbreakable web: From fragile scripts to bulletproof Workflows

Read Article

Billions of agents, one internet: Separating trust from threat

Read Article

How Numeral is Automating Sales Tax Compliance

Read Article

What can I use Browserbase for?

Read Article

You should own your browser.

Read Article

How Commure Achieved 20x Automation Scale with Browserbase

Read Article

Browserbase

Stagehand

Director

MCP

The Browser Blog

Building the future of web automation

Building the future of web automation

Read Article

Scalable Automation Starts Here: Meet Stagehand and MongoDB Atlas

Read Article

Cloudflare & Browserbase: Pioneering Identity for AI Agents

Read Article

What does Browserbase actually do?

Read Article

The unbreakable web: From fragile scripts to bulletproof Workflows

Read Article

Billions of agents, one internet: Separating trust from threat

Read Article

How Numeral is Automating Sales Tax Compliance

Read Article

What can I use Browserbase for?

Read Article

You should own your browser.

Read Article

How Commure Achieved 20x Automation Scale with Browserbase

Read Article