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

Derek Meegan

Harsehaj Dhami

As a Customer Engineer, I spend nearly all of my time resolving issues related to web automations. Truthfully, my job is primarily debugging other people’s code, and in that time, I have learned tons of expert-level ways to improve your life when it comes to building web automations. After speaking to hundreds of customers and sending thousands of customer support messages, here are the 7 best practices to build better web automations with Browserbase. 

**1. Browser Contexts: What is a browser context?**

A browser context is like an isolated, temporary browser profile with its own cookies, storage, and fingerprint. If you create a new page, you wipe that fingerprint. Browserbase creates a default browser context *for you.* Using this context is important because Browserbase preconfigures your fingerprint and stealth profile automatically, no setup required.

![](https://cdn.sanity.io/images/v773ixxh/staging/2b366c3b10d35afe01ab2dd15c62367362673bca-1200x342.png)

**2. Contexts API: What is the contexts API and how is it different than browser context?**

Great question! The contexts API is how Browserbase allows log-ins to specific accounts to be reused across multiple browser sessions without re-authenticating. This makes your automations more robust and fast, since the login step can be skipped and most antibot enforcements occur during login. Thanks to our partnership with [Web Bot Auth](https://www.browserbase.com/blog/cloudflare-browserbase-pioneering-identity) and [1Pass](https://www.browserbase.com/blog/1password-agentic-autofill), you can even manage and reuse credentials securely across teams and projects. No more hardcoded passwords or flaky login scripts.

![](https://cdn.sanity.io/images/v773ixxh/staging/74ad8e3208d104b6046e920c47171754530a9268-1200x625.png)

**3. Using CDP for PDFs**
* **What is CDP? What does it do?** 
The **Chrome DevTools Protocol (CDP)** is a set of JSON-based APIs that let you control, instrument, inspect, and debug Chromium-based browsers (like Chrome, Edge, Brave.
* **What does this have to do with PDFs?** Chrome uses a special web viewer for PDFs, which is different from a normal webpage. To process a PDF, you can enable downloads in the browser using CDP. **Alternatively** you can enable the PDF Viewer by setting enablePDFViewer to true in your browser settings. But I think CDP is better! 

![](https://cdn.sanity.io/images/v773ixxh/staging/1fc72449100705efc4fde73f8bf2fa96394018c4-900x838.png)

**4. Using CDP for Screenshots**

CDP is so great it also works for screenshots. If you want faster, higher-fidelity screenshots you can use CDP directly. 

![](https://cdn.sanity.io/images/v773ixxh/staging/f5d84f910185be008d4062440da735be13f680e0-900x518.png)

**5. Proxies: What is a proxy?**

A proxy server is **an intermediary that handles your internet requests, acting as a gateway between your device and the internet**. It receives your requests, forwards them to the destination server on your behalf, and then returns the data to you. Sometimes you need different proxies for different sites. Browserbase lets you define custom proxy routing rules, and you can even disable proxies for certain sites using our regex-based domain pattern argument.


![](https://cdn.sanity.io/images/v773ixxh/staging/e3ac303cedb8243c4325babe087c8af72d81abcc-900x702.png)


**6. Dialogues + Pop-Ups**

A dialogue window is a small pop-up that appears on top of a webpage when your browser needs user input or confirmation before continuing. These are typically difficult to interact with in web automation since they live outside of the normal web page.

Think dialogues are unreachable? Think again. Bypass dialogue pop-ups by adding an init script to your default context.

![](https://cdn.sanity.io/images/v773ixxh/staging/fc74561afbae854154ef74ffc0fc98db46cec4f8-900x369.png?w=450)

**7. Lean on the Community**

Lastly, if you run into issues, let us know! Web automation as a first-class solution is still an emerging space, but I can confirm that Browserbase’s support is excellent. Shoot a message to support@browserbase.com or join our Discord!

Web automation moves fast, and the tools keep getting smarter. The real edge comes from understanding how to combine them effectively: using features like Browserbase’s contexts, APIs, and CDP access to eliminate friction and focus on the logic that actually matters.

If there’s one thing I’ve learned from helping hundreds of teams, it’s that the difference between “it works” and “it works every time” is all in the details. Take the time to refine your approach, learn from the community, and keep experimenting. That’s where the real breakthroughs happen.

How to optimize your web automations using Browserbase and Stagehand. Article covers common best practices for improving automation scripts and shares unique features Browserbase offers.

Optimize your web automations using Browserbase

Peyton Casper

In September, we took our first major step toward solving agent identity with [Web Bot Auth](https://www.browserbase.com/blog/cloudflare-browserbase-pioneering-identity), a partnership with Cloudflare and Stytch that established a shared identity layer for how agents self-identify on the internet.

Today, we're taking the next step. We're excited to announce a [partnership with 1Password](https://blog.1password.com/closing-the-credential-risk-gap-for-browser-use-ai-agents/), the leader in credential management for enterprises and consumers alike.

Starting today, Browserbase customers can enable secure, instant access to any credential in their 1Password Vault for their browsing agents. This is enabled through [Director.ai](https://director.ai), our agent builder that lets anyone create and deploy browser automation with a single click.

## Why identity matters

Think about what agents actually do: they verify financial compliance, gather invoices, and execute transactions. Every single one of these actions requires credentials. And trust.

People have spent years building trust with their password managers, carefully securing everything from their email to their bank accounts. We can't expect them to maintain a separate credential system just for agents.

Agents need to meet users where they are. That's what this partnership enables.

## Three Pillars of Agentic Identity
We see identity for agents breaking down into three critical components:

![Three Pillars of Agentic Identity](https://cdn.sanity.io/images/v773ixxh/staging/9d7707dc2a61b6ab49ab42bd261d72f99cda379f-1342x980.png)

### Web Bot Auth

Web Bot Auth solves the fundamental question: how do agents prove who they are? These agents act on behalf of users and enterprises, and they need access to the same applications humans use. Web Bot Auth makes that possible.

### Credentials/2FA

Credentials and 2FA are the next layer. Agents need secure access to existing credential stores without forcing users to duplicate their entire security setup. This is where 1Password comes in, letting agents tap into the vaults people already trust.
**
### RBAC

RBAC (Role-Based Access Control) is the final piece, and it's critical for enterprise adoption. Not all agent actions are created equal. You want oversight when an agent executes a large transaction, but you don't want to drown users in constant approval prompts. Getting this balance right will define how agents scale in production.

We're already seeing this conversation emerge in the MCP space, and we're building for it now.

## What we're building for

This partnership represents more than an integration. It's a framework for how agents will access sensitive credentials going forward. Everyone at Browserbase and 1Password has been working tirelessly to make this real.

The vision is clear: agents that operate with the same level of access, security, and trust that humans have today. And infrastructure that makes it simple to build.

We're honored to help pioneer this experience, and we can't wait to see what everyone builds with it.

We're excited to see what you think, [get started today.](https://1password-video.s3.us-east-2.amazonaws.com/video.mp4)

<custom-cta text="Contact the Browserbase Identity team to learn more" button_text="Contact" button_link="https://www.browserbase.com/contact-1password"></custom-cta>

Today we are announcing a partnership with 1Password, the de facto leader in credential management for large enterprises and consumers.

Credential Access in the Agentic Web

Miguel Gonzalez

Sean McGuire 

The future of the web is agentic. Humans live in the physical world, but we increasingly find ourselves leaving our mark online (perhaps more than we'd like). We open our screens to do a little bit of everything, sometimes for fun, but often for tasks that are repetitive and boring. AI has potential to make browsing fun again, and become our trustworthy companion in navigating the web.

We're not there yet; the web is still a wild frontier for AI. Teaching models to reason, explore, and act within it is no small feat. That’s why we partnered with Google DeepMind, leveraging the Browserbase infrastructure to help train, evaluate, and deploy the newest generation of Gemini models, reaching new state-of-the-art levels in accuracy, speed, and cost.

## New Ceilings, New Opportunities

We have been working closely with Google DeepMind to help evaluate and measure the progress of their new `gemini-2.5-computer-use-preview-10-2025` model. Stagehand, our fully open source framework, provides a provider-agnostic interface for computer use models, making it easy to swap and compare models against one another. To help track progress and compare different models, we added support for multiple benchmarks like [OnlineMind2Web](https://huggingface.co/datasets/osunlp/Online-Mind2Web) and [WebVoyager](https://huggingface.co/papers/2401.13919), as well as our custom set of evals for both atomic actions and agents. 

Over the past couple of months, we accumulated over 200 experiment runs, combining for a total of ~4,000 browser hours (almost 6 months of runtime). The results speak for themselves:

## OnlineMind2Web @ 50 steps
[![](https://cdn.sanity.io/images/v773ixxh/staging/0247a8fe8ea0d1b8ce0019b5a0357f44dfd5c602-2438x1452.png)](https://www.stagehand.dev/agent-evals)
## Webvoyager @ 75 steps
[![](https://cdn.sanity.io/images/v773ixxh/staging/2ead519f1b2148b14c7234b28989585b1597c5d7-2444x1458.png)](https://www.stagehand.dev/agent-evals)

The new Gemini 2.5 Computer Use models outperform every other major provider in accuracy, speed, and cost. Every model was tested through their publicly accessible API, with the same constraints on steps, timeouts, and stealth+performance environment capabilities. The new computer-use-preview model from Google presents a paradigm shift; allowing builders to create more with less, faster than ever.

## Manipulating Time
By providing scalable infrastructure for running browsers in the cloud and observability to understand exactly what actions the models are taking, Browserbase helps cut the training and evaluation time from months to minutes. Instead of running the agents on a single browser and waiting for a task to complete before moving on to the next, it's possible to branch off and train and evaluate in parallel—all at the same time. 

Thanks to Browserbase's concurrent browser infrastructure, we were able to condense ~18 browser hours into 20 minutes of total runtime. 

![](https://cdn.sanity.io/images/v773ixxh/staging/2df39a75d2d03c4523120230dab8832d8c7b2fba-1945x1094.png)


With this scale, total time for a given run is limited by an agent's time taken to complete a single task. Faster iteration, observability into mishaps, and feedback on improvements all combine into a recipe for training capable browser agents that navigate the web better than we do (yes, many times we find ourselves trying to keep up on what the agent just did). 

## Challenges of Benchmarking Browser Agents
Tracking progress and testing web agents is a challenging process. Websites change, traffic gets blocked, and the goals for certain tasks become obsolete over time.

There are two main approaches to mitigating the above issues:

### 1. Cloning websites

This approach involves making a best-effort copy of an existing website, and having the browser agent navigate within the copied website instead of the original. 

### 2. Using real websites

This is the approach that evaluation datasets like WebVoyager have taken. This approach involves creating a set of prompts or tasks coupled with starting URLs, and then evaluating whether the agent completed said task.

Both of these approaches are imperfect, and come with their own sets of challenges. The problem with cloned websites is that they often do not emulate the real World Wide Web, or perhaps better described as the Wild Wild Web. A static website in a controlled environment doesn’t capture the unpredictable nature of navigating a live, hosted website. There are no surprise cookie popups, captchas, iframes with ads, or slowly loading content. A lot of what makes the web challenging for agents becomes controlled.

Using real websites is also a huge challenge because of how frequently they change. A task that worked yesterday may be impossible tomorrow. For example, here is a [task](https://github.com/MinorJerry/WebVoyager/blob/5a7896738c10bfb8b9edccce6bb0e0411f8ae569/data/WebVoyager_data.jsonl#L223) from the WebVoyager dataset:


```json
{
	"web_name": "Booking", 
	"id": "Booking--8", 
	"ques": "Get the hotel with highest review score and free cancelation in Chennai for 20/12/2023 - 21/12/2023.", 
	"web": "https://www.booking.com/"
}
```

Obviously, given today's date, the above task is impossible. But what should we do with this task? Should we include it in our evaluation? It doesn’t seem like a fair evaluation, and it certainly doesn’t provide any useful data on how the agent performed. But what about other people evaluating their web agents? Did they include this task? 

The easiest thing to do here is to remove or replace tasks like this, but over time, this ends up with people benchmarking against a slightly different subset of tasks. If everyone is using different tasks, then is the benchmark even a benchmark?

### The Path Forward

We believe the path forward lies in **transparency and collective calibration**.

Instead of quietly pruning benchmarks and omitting tasks, we’re publishing [**the full set of 3,772 human-verified evaluations**](https://www.browserbase.com/blog/evaluating-browser-agents#footnotes), including traces and scores for every run — successful or not. By making the raw data public, we invite others to spot ambiguous or outdated tasks, propose updates, and help shape a more stable foundation for measuring progress.

To make this process accessible, we’ve also open-sourced the [**Stagehand Evals CLI**](https://github.com/browserbase/stagehand/tree/main/evals), enabling anyone to reproduce our experiments, inspect failures, and run their own agent comparisons locally.

We’re also providing day-1 support for the new model in Stagehand (TypeScript and Python). Getting started is as simple as:

```TypeScript
# TypeScript
npx create-browser-app --template gemini-cua
```
```Python
# Python
uvx create-browser-app --template gemini-cua
```

You can also try it on Google’s official quickstart repo: https://github.com/google/computer-use-preview

If you’re not worried about benchmarks, and prefer to evaluate based on ✨ vibes ✨, we’re also launching the [Browser Agent Arena](https://arena.browserbase.com). You can define a task and see which computer use model performs the best. 

This partnership with Google DeepMind is just the beginning. Models are becoming more capable, soon operating a browser faster than a human can. 

Instead of rebuilding the internet for AI, soon AI will be browsing alongisde us. This is an exciting future, where every interface becomes programmable and every digital task can be automated

The future is agentic, and it starts now.

We can't wait to see what you 🅱️uild!

### Footnotes
- [OpenAI Mind2Web](https://www.braintrust.dev/app/Browserbase/p/stagehand-dev/experiments/OPENAI-agent%2FonlineMind2Web_browserbase_20250926053440?c=GOOGLE_OLD-agent/onlineMind2Web_browserbase_20250926044532&g=[%22metadata%22,%22difficulty%22])
- [Google Mind2Web](https://www.braintrust.dev/app/Browserbase/p/stagehand-dev/experiments/GOOGLE_NEW-agent%2FonlineMind2Web_browserbase_20250926040431?c=agent/onlineMind2Web_browserbase_20250926040323&g=[%22metadata%22,%22difficulty%22])
- [Anthropic Mind2Web (sonnet 4)](https://www.braintrust.dev/app/Browserbase/p/stagehand-dev/experiments/ANTHROPIC-agent%2FonlineMind2Web_browserbase_20250926062208?c=OPENAI-agent/onlineMind2Web_browserbase_20250926053440&g=[%22metadata%22,%22difficulty%22])
- [Anthropic Mind2Web (sonnet 4.5)](https://www.braintrust.dev/app/Browserbase/p/stagehand-dev/experiments/ANTHROPIC-SONNET-4.5-agent%2Fwebvoyager_browserbase_20250929223935?c=agent/onlineMind2Web_browserbase_20250929191208&g=[%22metadata%22,%22website%22])
- [OpenAI WebVoyager](https://www.braintrust.dev/app/Browserbase/p/stagehand-dev/experiments/OPENAI-agent%2Fwebvoyager_browserbase_20250928044215?c=ANTHROPIC-agent/webvoyager_browserbase_20250928044119)
- [Google WebVoyager](https://www.braintrust.dev/app/Browserbase/p/stagehand-dev/experiments/GOOGLE-agent%2Fwebvoyager_browserbase_20250928191012?c=agent/webvoyager_browserbase_20250928183557&g=%5B%22metadata%22,%22website%22%5D)
- [Anthropic WebVoyager (sonnet 4)](https://www.braintrust.dev/app/Browserbase/p/stagehand-dev/experiments/ANTHROPIC-agent%2Fwebvoyager_browserbase_20250928044119?c=agent/webvoyager_browserbase_20250928043940)
- [Anthropic WebVoyager (sonnet 4.5)](https://www.braintrust.dev/app/Browserbase/p/stagehand-dev/experiments/ANTHROPIC-SONNET-4.5-agent%2Fwebvoyager_browserbase_20250929223935?c=agent/onlineMind2Web_browserbase_20250929191208&g=[%22metadata%22,%22website%22])

We have been working closely with Google DeepMind to help evaluate and measure the progress of their new computer-use-preview model. Stagehand, our fully open source framework, provides a provider-agnostic interface for computer use models, making it easy to swap and compare models against one another. To help track progress and compare different models, we added support for multiple benchmarks like OnlineMind2Web and WebVoyager, as well as our custom set of evals for both atomic actions and agents. 

Training & Evaluating Browser Agents - Our Journey with Google Deepmind

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.

At Browserbase, we believe **identity is a critical layer for AI on the web**. That’s why we’re excited to announce our partnership with **Stytch**, who is joining us in supporting [**Web Bot Auth**](https://developers.cloudflare.com/bots/reference/bot-verification/web-bot-auth/) as an open standard for trustworthy agent identification.

Together, we’re helping create a web for AI agents that is secure, transparent, and most importantly doesn't have gatekeepers.!


![](https://cdn.sanity.io/images/v773ixxh/staging/f8f813fc8c29a784ce1d6576e7cfc71cfeb51848-6400x3600.png)


---

## Why Identity Matters for AI

Until now, bots and agents have relied on weak, spoofable signals like User-Agent headers or static IPs to identify themselves. That doesn’t scale.

- **Websites can’t tell good actors from bad ones.**
- **Responsible agents get blocked alongside malicious bots.**
- **Users lose out on the value agents could deliver.**

Web Bot Auth changes that by introducing **cryptographic identity** for agents. When an agent browses the web on your behalf, it presents a verifiable signature that websites and anti-bot providers can trust.

---

## Why We’re Excited About Stytch

Stytch brings deep expertise in **developer-first identity infrastructure**, and their early adoption of Web Bot Auth is proof that the ecosystem is coming together around open standards. With Stytch’s support:

- Website operators get **simpler ways to verify agents** via their IsAgent SDK.
- Bot operators can integrate without proprietary registration or lock-in.
- The ecosystem grows stronger, faster.

This collaboration shows how companies across the stack can work together to build trust for agents at scale.

---

## What’s Next

Momentum around Web Bot Auth is real:

- **Cloudflare** is validating traffic at the edge.
- **Stytch** is enabling simple verification.
- **Browserbase** is the infrastructure layer ensuring AI agents can browse reliably with that identity.

We’re proud to help shape this future alongside partners who share our belief in an **open, trustworthy web for humans and AI alike**.

If you’re an AI company building agents and want to join the early wave of adopters, [get in touch with us here](https://www.browserbase.com/contact-web-bot-auth).

<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>

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.

Browserbase & Stytch: Building a Trusted Identity Layer for AI Agents

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

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

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.

The Browser Blog

Building the future of web automation

Building the future of web automation

Read Article

Optimize your web automations using Browserbase

Read Article

Credential Access in the Agentic Web

Read Article

Training & Evaluating Browser Agents - Our Journey with Google Deepmind

Read Article

Browserbase & Stytch: Building a Trusted Identity Layer for AI Agents

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