The biggest thing holding agents back isn’t model capabilities, but access to the systems we use every single day.

We want agents to do work on our behalf. But most of that work (logins, forms, dashboards, documents) aren’t exposed via APIs. They’re accessible via the web, and through interfaces designed for humans.

The web is fragmented, and agents are missing the tools needed to access it. But the tools are fragmented too.

Creating best in class browser agents means stitching together search, fetch, browsers, sandboxes, and models across multiple vendors. You need 6 API keys just to build the “Hello World”.

That’s why at Browserbase, we’re unifying the browser agent stack.

All with one Browserbase API key.

Teams at Shopify, Ramp, and Lovable are already building browser agents on Browserbase. You can too.

Browsers

The moment every browser agent hits the wall

There’s a point in almost every browser agent project where things stop feeling easy.

Up until then, everything looks pretty promising. The model understands the task, the reasoning is sound, and the outputs make sense. Surely, it’s ready for the world … surely not. The moment the agent needs to actually to log into a system, submit a form, retrieve a document, or navigate a workflow, it runs into friction.

Tons of things go wrong. Maybe pages don’t render as expected or content is hidden behind JavaScript. Or, the API you assumed would exist doesn’t. All that seems straightforward becomes painfully brittle.

This is because your agent doesn’t actually have access to the web. An API only gets you 15% of the way there.

The tools exist, but there are too many pieces

To solve this, developers will naturally assemble a stack:

  • Search to figure out where to go.
  • Fetch to see what’s on the page.
  • Browsers to click buttons and submit forms.
  • Functions to run code in a sandbox.
  • Models for reasoning.
  • Observability to debug failures.

Don’t get me wrong, each piece absolutely works individually. The real issue is that none of them are designed to work together as a system.

Every step of your browser agent’s workflow crosses a boundary between vendors, runtimes, logs, and failure modes. So when something breaks (and it always does), you’re really debugging the seams between the tools, rather than the agent logic itself a lot of the time.

We just want an agent to do the thing. Browser agents need to see and access the other 85% of the web for that to happen.

So we built the whole platform, with unified observability and logging, to make it seamless for anyone to build production-ready browser agents.

From component to the platform

Browserbase started by solving one of the hardest problems in infrastructure: running browsers reliably in the cloud. If an agent needs to behave like a human, it needs a real browser that delivers.

But after working with thousands of developers, continued to see teams solve the browser layer with Browserbase, only to run into friction with other parts of the stack. And your agent is only as reliable as it’s weakest link.

Instead of building better individual tools, we built a platform where every part of the browser agent stack runs on the same underlying infrastructure.

Search, fetch, browsers, identity, sandboxes, and models are no longer separate integrations. Instead, they’re primitives in one system.

How browser agents work when the system is unified

Reliable browser agents still follow the same journey, but now work within a unified platform that keeps the context together for best-in-class reliability.

Navigating the web with Search

Before they browse, agents need to figure out where to go.

Rather than hardcoding URLs or relying on guesswork, agents can use Search to find the right destination dynamically.

import { Browserbase } from "@browserbasehq/sdk";

const bb = new Browserbase({ apiKey: process.env.BROWSERBASE_API_KEY! });

const searchResponse = await bb.search.web({
  query: "the most reliable web browser for ai agents",
  numResults: 10,
});

Retrieving web context with Fetch

Once the agent has a destination, it doesn’t always need a browser. Often, the fastest step is simply retrieving the page content to understand what’s there.

This is where Fetch comes in.

import { Browserbase } from "@browserbasehq/sdk";

const bb = new Browserbase({ apiKey: process.env.BROWSERBASE_API_KEY! });

const response = await bb.fetchAPI.create({
  url: "https://browserbase.com",
});

console.log(response.statusCode);
console.log(response.content);

Fetch gives agents a lightweight way to inspect pages before deciding whether deeper interaction is required.

Interacting with the web with a browser

When the workflow requires interaction (like logins, dynamic content, multi-step flows), the agent escalates to a real browser.

const bb = new Browserbase({
  apiKey: process.env.BROWSERBASE_API_KEY!,
});

// Create a new session
const session = await bb.sessions.create();

This is where Browserbase’s core infrastructure takes over, providing production-grade browsers with full observability and session recordings so you can see exactly what happened when something fails.

Identity makes the web usable

One of the most overlooked challenges in building browser agents is identity.

Despite most things working correctly, most agents fail here because every browser session looks like a new, unknown user. Without continuity, websites treat them that way, so sessions break and workflows fail.

We’ve solved this problem thanks to Agent Identity.

In partnerships with Cloudflare, Fingerprint, and 1Password, we’ve enabled agents to operate with a consistent, verifiable presence across sessions. We’ve combined cryptographic identity (Web Bot Auth), stable browser signals, and safe access to real user credentials.

Once your agent can reliably access the web, the next challenge is deciding what to do next consistently, and at scale.

Making models easy to change with Model Gateway

Agents still rely on models to reason, but managing multiple providers adds unnecessary overhead. Different models are better at different things. Some are faster, some are cheaper, some are more reliable. In practice, you end up wanting to switch between them constantly.

The Browserbase Model Gateway provides a unified interface to access and switch between models (from Anthropic, OpenAI and Gemini) with a single API key using Stagehand:

# before
const stagehand = new Stagehand({
   env: "BROWSERBASE",
   apiKey: process.env.BROWSERBASE_API_KEY,
   model: {
      modelName: "openai/gpt-5",
      apiKey: process.env.OPENAI_API_KEY,
    },
});
# after
const stagehand = new Stagehand({
	env: "BROWSERBASE",
  model: "openai/gpt-5", // or “anthropic/claude-sonnet-4-6” / “google/gemini-3-flash-preview”
});

This removes friction from experimentation and allows your stack to evolve as models improve.

From prototype to production with Functions

The final challenge is getting agents to run reliably outside your laptop.

An agent that works locally often fails when it needs to run continuously, handle retries, or manage state. Browserbase Functions solves this by letting you run agents directly within Browserbase. Your agents are close to the browser infrastructure, with better performance and debugging.

What changes when it’s one system

Browsers, search, fetch, identity, models, and execution all exist today, but separately.

Bringing them together changes this experience when you’re no longer stitching vendors together or debugging across multiple systems. You’re working within one platform that understands your browser agent’s job.

You can piece together a million tools, but at the end of the day again, I just want my browser agent to do the thing. By unifying the stack, we can move further up it. One platform, one API key, and one person. It’ll get the job done now.

Build agents that can access 100% of the web

Teams at Lovable, Ramp, and Clay are already building agents with Browserbase.

Now you can do the same, without stitching the stack together yourself. Ambitious ideas need more than APIs. Give them access to the rest of the web. ;)

Get your API key to the web

Our pricing has also been updated to reflect the platform: bundled, flexible, and aligned with how agents are actually built and scaled. See all of the updates here.