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

Harsehaj Dhami

## Playwright got us here - where we’re going next
Stagehand began as an AI-centric layer built on Playwright, adding new capabilities like `act`, `extract`, and `observe` on top of its existing API. That choice lets developers plug Stagehand into existing scripts in minutes and ship real automations fast. As the community has grown and our ambitions are expanding, we have run into the natural limits of building on a test‑first framework. This post is a look back at why Playwright was the right starting point, and why we’re taking Stagehand deeper into the browser stack.
## Why we started on Playwright
In the early days, our goals were clear: remove friction, meet developers where they are, and earn trust. Returning a Stagehand‑enhanced `Page` / `Context` meant your Playwright code kept working, now with AI‑powered primitives on the same object. 

**Result: minimal migration, lots of adoption, and a fast feedback loop with real users.** The [docs](https://docs.stagehand.dev/first-steps/introduction) still say it best: *“Full Playwright compatibility… use any Playwright API alongside Stagehand.”* 

That compatibility made Stagehand a great **and** pragmatic choice for teams taking their first steps into AI‑assisted automation with us.
## What changed as we scaled
As Stagehand and our community have grown, we’ve noticed a few seams showing. Less about **quality** and more about **fit**.
### 1) Testing DNA vs. automation throughput
Playwright’s [actionability checks and auto‑waiting](https://playwright.dev/docs/actionability) are fantastic for end‑to‑end tests: click only when an element is visible, stable, enabled, and receiving events. For automation, where we often want to move quickly and accept more direct control, those checks can add latency and complexity we don’t always need.
### 2) We need CDP‑level control (especially for frames)
Stagehand builds rich, structured context for models by reading directly from the Chrome DevTools Protocol (CDP): accessibility trees, DOM snapshots, network events, and more. Doing that well requires stable identifiers and precise scoping. This is where we hit friction:

- **Frame identity & scoping.** Playwright [doesn’t expose a unique frame ID](https://github.com/microsoft/playwright/issues/30261), which makes lifecycle tracking and per‑frame CDP routing harder than it needs to be.
- **Practical interop gaps.** As Sean [wrote](https://www.browserbase.com/blog/taming-iframes-a-stagehand-update) in our [iframes update](https://www.browserbase.com/blog/taming-iframes-a-stagehand-update), Playwright and CDP don’t always play perfectly together when you need to target CDP to specific frames and stitch multi‑frame state back together. We worked around this with a unified tree, deep XPath locators, and smarter session mapping, but this was all work we had to do because of those gaps.
- **Per‑page CDP sessions.** Playwright exposes CDP via [`CDPSession`](https://playwright.dev/docs/api/class-cdpsession), typically scoped from a page/context. That’s useful, but once you’re doing heavy CDP‑first work, you want finer‑grained control and fewer round‑trips.

In short: when a product **is** automation (not testing), we eventually **want to operate at the protocol layer without extra hurdles.**
### 3) Operational headroom matters
Our users have reported memory growth in long‑running sessions and version‑specific regressions. Even when issues are addressed upstream, staying strictly on the Playwright rails can make it harder for us to choose different tradeoffs for long‑lived automation workloads.

![](https://cdn.sanity.io/images/v773ixxh/staging/c247f25d946eda2a893ad29a9f7ac6436de3d2f6-2858x1691.png)
## What we learned building on top of Playwright
- **It was the fastest on‑ramp.** Developers could drop Stagehand into existing code and get value right away.
- **The surface area is huge.** A testing‑first framework brings a long tail of APIs and behaviors we don’t lean on, and maintaining perfect fidelity to that surface area constrains how fast we can ship automation‑first features.
- **Frames are the real world.** Modern sites are a thicket of same‑origin and out‑of‑process iframes. Doing great work there means embracing CDP deeply and minimizing requests sent over the websocket (Our [iframes post](https://www.browserbase.com/blog/taming-iframes-a-stagehand-update) walks through the details).
## Principles guiding the next phase
We’re codifying a few principles that reflect what our users actually need:

1. **Automation‑first semantics.** Keep the ergonomics developers love, but put throughput and control ahead of test ergonomics (you can still opt‑in to waiting and safety rails when you need them!).
2. **CDP‑native performance.** Expose the right hooks so Stagehand can build context efficiently (fewer, smarter messages), especially across iframes, workers, and tabs. 
3. **A smaller core, fewer surprises.** Focus on the primitives that matter for automation without absorbing unrelated testing machinery.
4. **Compatibility where it counts.** Developers shouldn’t have to rewrite everything to benefit from these changes. The spirit of “drop‑in and go” stays.

Playwright has been a terrific foundation: a clean mental model, a mature ecosystem, and an incredible community. It has helped Stagehand hit the ground running and reach far more developers, far more quickly, than we could have alone. As we keep pushing what’s possible in browser automation, we’re taking the lessons (and the gratitude) with us.

Stagehand’s mission hasn’t changed: give developers and models a browser they can *trust*. The work ahead is about sharpening that promise: making the core smaller, the behavior more predictable, and the performance feel native to the metal. 

More soon. :)

<custom-cta text="Build automations with Stagehand" button_text="Get started" button_link="https://docs.stagehand.dev/first-steps/introduction"></custom-cta>

Stagehand began as an AI-powered layer on top of Playwright. As we’ve scaled, we’ve outgrown its test-first design. Here’s how we’re rethinking automation from the ground up.

Why we’re graduating from Playwright

We each have a browser on our computer, but the web becomes truly powerful when you can run hundreds of browsers in the cloud and let AI use them. That’s why we built [Browserbase](https://www.browserbase.com/): a place to spin up real, isolated, observable browsers on demand.

Today, we’re opening that capability up in a way that’s radically simple: [Director](https://www.director.ai/). With just a natural‑language prompt, anyone can create repeatable browser agents that complete complex, multi‑step tasks online, and export the exact code those agents use, so you can run them again and **again** in production.

> “Find me a developer on Upwork with web automation experience.”
> 
> “Log in, grab the newest PDF from the city records portal, and file it in our S3 bucket.”
> 
> “Fill this survey 1,000 times using rows from a CSV.”

Director handles this (+ more) click‑by‑click in a **real browser you can observe.**

![](https://cdn.sanity.io/images/v773ixxh/staging/30a75086e8695888883d40a32d082313a7547304-2199x1316.jpg)

## Browser automations for all

When we [first released Director](https://www.browserbase.com/blog/introducing-director), it was a promising experiment: *“What if you could describe a task in English, and an agent could carry it out in a browser?”*

Most “AI browsing” features are ephemeral: you give a prompt, an LLM puppeteers a page, and you’re left with… nothing reusable. On the other end, traditional RPA and headless automation demand significant engineering to be robust. **Director collapses this gap.**

Director is a full-fledged automation platform that can take on enterprise-scale workflows and write its own reliable, reusable code as it goes. It records every step it takes into repeatable [Stagehand](http://stagehand.dev/) code. That means your automations are no longer just “AI runs.” They’re programs you can own, edit, and deploy.

Once you’ve built a workflow, you can deploy it instantly on Browserbase’s cloud infrastructure, running hundreds of browsers in parallel. Perfect for scaling across entire datasets or monitoring thousands of pages at once. Director can hand off control to you for sensitive steps, like logins or payments, with native **[1Password integration](https://docs.browserbase.com/integrations/1password/introduction)** that keeps credentials secure and out of the agent’s view.

Under the hood, we’ve made huge upgrades to how Director interprets and executes instructions. It’s now able to handle multi-step reasoning, dynamic page flows, and context changes across sites (things that used to break traditional web agents or scrapers).

<custom-cta text="Get started with Director" button_text="Go!" button_link="https://www.director.ai/"></custom-cta>

## How Director works

1. **Describe the task** in plain English.
2. **Watch the agent work** in a real browser: clicks, form fills, downloads, navigation.
3. **Approve sensitive steps** (e.g., login) via manual control or 1Password.
4. **Export Stagehand code** that mirrors the successful run.
5. **Deploy on Browserbase** to run once, on a schedule, or at massive parallel scale.

## What you can build today

- **Fill tedious forms at scale** (hundreds or thousands of submissions)
- **Monitor public records** and fetch new PDFs daily from municipal portals
- **Given an unknown URL**, find and extract specific data points
- **Evaluate websites** for accessibility and UX guidelines
- **Verify professional licenses** across state or country registries
- **Check ADA compliance** with Street View & site heuristics
- **Migrate data** between CRMs when bulk export/import isn’t available

We’d love to hear more success stories from you. Head over to [Director](http://director.ai) today and give the agent your most ambitious web task!

## We’re launching on Product Hunt, come support us! 🎉

We’re excited to share Director with the Product Hunt community. If you like what we’re building, **an upvote, comment, or question goes a long way,** and helps others discover it.

👉 **Join the launch & support us on Product Hunt:** **[producthunt.com/products/director](https://producthunt.com/products/director)**

**What to do when you get there:**

- Upvote if you think Director should exist
- Leave a comment with a task you want automated
- Share feedback! We’re reading every note

<custom-cta text="Our Product Hunt launch!" button_text="Support us" button_link="https://www.producthunt.com/products/director"></custom-cta>

## Get started with Browserbase

- **Try Director:** [https://director.ai](https://director.ai/)
- **Run browsers in the cloud:** https://www.browserbase.com/
- **Under the hood:** [http://stagehand.dev](http://stagehand.dev/)
- **Secure credentials:** [1Password integration](https://docs.browserbase.com/integrations/1password/introduction)

Have an ambitious web task? Point Director at it. We’d love to hear your results.

Director is now more powerful than ever, and we’re launching it on Product Hunt. See how you can automate complex web tasks, export real code, and deploy at scale with Browserbase.

Launching Director on Product Hunt

APIs are great when they exist, when they’re documented, and when they **actually** work. But most businesses rely on a tangle of web apps, portals, and dashboards that don’t talk to each other. The *“No-API Enterprise”* is what happens when teams stop waiting for integrations and start automating the work as they already do it: right through the browser.

These automations aren’t glamorous. They’re the quiet, repeatable ones that keep operations running smoothly: paying bills, checking licenses, updating CRMs, verifying data, or filing routine forms. 

Let me walk you through a few workflows we’re seeing teams automate with Browserbase today.

### 1. CRM hygiene that actually sticks
Sales and ops teams use automation to keep their CRMs from falling out of sync. After a call ends, an automation logs into Salesforce or HubSpot, adds meeting notes, updates lead statuses, and even creates follow-up tasks. For larger migrations, it loops through a spreadsheet of contacts, updates what exists, and fills in what’s missing. Each evening, the automation posts a quick digest to Slack so everyone can see which records were refreshed and which still need a touch.

![](https://cdn.sanity.io/images/v773ixxh/staging/5b9dc93527fc0443a5695226b4f497a5642d4a1b-1572x288.png)

### 2. Bill pay and franchise tax, minus the portal hopping
Finance teams often juggle a dozen vendor logins just to download invoices or pay small bills. Automations now handle that grunt work: logging into each portal, grabbing receipts, filing franchise tax payments, and archiving PDFs in one shared folder. Every month, the automation posts a single message in Slack with a link to the folder and a simple green checkmark.


![](https://cdn.sanity.io/images/v773ixxh/staging/cee30ecb83e83eafccd5cb310c5421b01fdf3ccd-1412x215.png)

### 3. Everyday security checks, done quietly
Every company needs to keep an eye on its digital footprint, but that doesn’t mean wiring up endless integrations. A small automation can log into the same security tools your team already uses, check for new alerts, and file what matters. One daily run might visit “Have I Been Pwned” for domain breaches, review AWS GuardDuty alerts, and file a takedown if something sensitive appears online. Peace of mind and less manual checking!


![](https://cdn.sanity.io/images/v773ixxh/staging/d440ee899dc2c50680caf51679ebba098528d287-1363x166.png)


### 4. License and registry checks that run themselves
Legal and compliance teams constantly verify that licenses and public records stay current. Automations now handle this by filling out state lookup forms, pulling results, and flagging expirations. Whether it’s a medical license, real-estate registration, or a state filing, the automation quietly compiles the data into a live spreadsheet and sends a heads-up before anything lapses.

![](https://cdn.sanity.io/images/v773ixxh/staging/2d494349999f8818a5526687705feeea435e5e46-1714x194.png)

### 5. Price and availability checks for real-world ops
When a customer asks “Who can deliver today?”, procurement or support doesn’t have time to visit ten sites. Instead, an automation searches retailer pages, enters ZIP codes, compares prices and delivery windows, and returns the best option. The output is a quick table (vendor, cost, ETA) that can be dropped right into a Slack message or internal doc.

![](https://cdn.sanity.io/images/v773ixxh/staging/fd5b7c6a5685157a085bf4da7615132251073f02-1838x176.png)

### 6. Logistics and travel that stay on track
Whether it’s ferries, trains, or container shipments, delays happen. A simple browser automation can monitor those public schedules, capture updates, and even start rebooking if a delay crosses a certain threshold. Instead of a wall of information and alerts, teams now wake up to a clean dashboard that answers one question: “Are we on time?” 

![](https://cdn.sanity.io/images/v773ixxh/staging/ff907f23c6d3f88e3241b48fa57ddc9d15940b0e-1812x166.png)

### 7. Revenue and investor data, straight from the source
Finance and leadership teams often need data that is gated behind logins, like MRR snapshots from NetSuite or earnings calendars from investor sites. Rather than waiting for IT, an automation logs in (enabled by our [1Pass partnership!](https://www.browserbase.com/blog/1password-agentic-autofill), exports the report, and updates a shared sheet or Slack summary. The team gets up-to-date numbers without anyone having to click through dashboards.

![](https://cdn.sanity.io/images/v773ixxh/staging/e6a401175b5d292553af1780a27054378b5f6bea-1724x154.png)

### 8. People and territory updates on autopilot
RevOps and HR teams use automation to keep people data current. Each week, an automation pulls the latest roster from HR software, checks employee locations on LinkedIn, and compares them to assigned territories in the CRM. If something’s off (maybe, a rep moves regions) it flags it for review. So, cleaner records and fewer mismatched accounts!

![](https://cdn.sanity.io/images/v773ixxh/staging/da024058f2516e90be4214af90bad00faa18b6e7-1762x166.png)

The No-API Enterprise runs on the same principle that drives Browserbase: make the browser programmable, reliable, and safe for automation. Each of these workflows, whether it’s fetching invoices, filing taxes, or checking security alerts, uses the browser as the integration layer. **Browserbase turns that idea into infrastructure:** managed sessions, secure authentication, observability, and everything needed to keep these automations running at scale.

<custom-cta text="Automate the web. :)" button_text="Get started" button_link="https://www.director.ai/"></custom-cta>

Learn how teams automate CRM updates, bill payments, compliance checks, and more with Browserbase, turning everyday web workflows into scalable automation.

8 workflows teams automate today with Browserbase

Derek Meegan

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.

1Password & Browserbase - Pioneering Agentic Autofill for Credential Access

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.

The Browser Blog

Building the future of web automation

Building the future of web automation

Read Article

Why we’re graduating from Playwright

Read Article

Launching Director on Product Hunt

Read Article

8 workflows teams automate today with Browserbase

Read Article

Optimize your web automations using Browserbase

Read Article

1Password & Browserbase - Pioneering Agentic Autofill for Credential Access

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