Describe a goal in plain language, get a browser agent you run with a single API call. No code to write, deploy, or maintain.

TL;DR: Browserbase Agents is a managed browser agent you create from a natural language prompt and run with one API call. Hand it a goal, get back structured results, and reuse the same agent across hundreds of sites without writing or maintaining a script per target. It runs on the same infrastructure behind 35M+ browser sessions a month, and it is generally available today on every plan.

If you run browser automations today, you already know the struggle. Every site you add is another script to write, every redesign is another script that breaks, and scaling past a handful of targets means standing up queues and workers before you have automated anything useful.

Browserbase Agents replaces all of that with a single browser agent, an AI system that navigates and acts on websites the way a person would, directed by natural language. Describe a goal, send one API call, and get a reusable agent that adapts when pages change and returns clean, structured results. And unlike the scripts it replaces, it improves over time: every agent can be tuned to run faster and more reliably the more you use it. It all runs on the same platform behind 35M+ browser sessions a month for teams like Ramp, Shopify, and Lovable.

What is a Browserbase Agent?

A Browserbase Agent is a browser agent you create by describing a goal, not by writing selectors. Under the hood it runs on the full platform, with browsers at the center: real headless browsers handle the interaction, Agent Identity gets the agent past anti-bot systems and authentication walls, and Search and Fetch pull web context when a full session would be overkill. Every step is recorded for you to inspect. The web was never built for agents, so making one reliable takes a real harness underneath.

The difference from building it yourself is the deployment story. With our SDK, Stagehand, you wire up and host the agent loop in your own infrastructure. With Browserbase Agents, there is nothing to host. You describe the goal, we run the agent, you get the result back.

How it works

There is no framework to learn and no code to deploy. You write the goal the way you would brief a teammate, in plain language, and send it with a single API call. The agent runs on our infrastructure, decides how to navigate each site for itself (how much autonomy an agent should have is a design question in its own right), and adapts to the layout differences and per-site quirks that break hand-written scripts.

Runs are asynchronous, so a long job never blocks your request. You start a run and check back on it when it is done. And because every run takes a result schema you define, what comes back is structured, typed data shaped exactly the way you asked, ready to drop straight into your system with no parsing or cleanup.

Create the agent once and point it at the next portal, then the one after that. One agent covers the long tail that used to take one script per site.

See every run

A managed agent is only useful if you can trust it, and trust comes from being able to watch it work. Every run is a real browser session with full observability built in: a live view of the browser as the agent acts, Session Replay to scrub back through any completed run, and traces across both model calls and tool calls so you can see exactly why the agent did what it did, alongside a per-run cost breakdown.

When an agent does something strange, you do not guess. You open the run and watch the frames it saw.

Agents that get better over time

Shipping an agent is the start, not the end. Optimize takes a working agent and tunes it three ways:

• Make faster: trim the steps a run takes so it finishes quicker and costs less
• Debug: investigate a run that went wrong and correct the behavior behind it
• Refactor: restructure the agent as the task grows, so it stays reliable instead of drifting

The agent you ship in week one is not the agent you are stuck with. It improves as you run it, the first step toward agents that get better largely on their own, which is where we think this is all heading (more on that in Autobrowse).

What you can build

Browserbase Agents fits the work that was always too varied to script cleanly and too large to script one site at a time:

• Monitoring: track pricing and competitor changes across dynamic, protected sites
• KYC and KYB across customer and business portals that all look different
• Government and real estate records: pull tax documents and property records across 1,500+ county and state sites
• Document retrieval: find SOC 2 reports, authorization forms, and transaction documents wherever they live
• Automated QA for teams scaling their product development with coding agents

The common thread is the long tail. One agent covers 200 portals instead of 200 scripts, and it keeps working when those portals change.

Get started

Browserbase Agents is generally available today on every plan, with included runs to start building right away:

Describe your first agent and run it in a single call. Read the docs to get started.

The web was built for humans. Now your agents can use it like one.