Browserable – Open Source Browser Automation for AI Agents

TL;DR

TL;DR: Browserable is an open-source Node.js library and self-hosted runtime that lets AI agents control a real browser — navigate pages, fill forms, click elements, and extract structured data. It scores 90.4% on the Web Voyager benchmark and runs fully on your own infrastructure.

What Is Browserable?

Browserable is an open-source browser automation library built specifically for AI agents. Unlike traditional tools like Playwright or Puppeteer that require manual scripting, Browserable exposes a natural-language-friendly interface that lets an LLM drive browser actions autonomously.

From the project’s README:

Browserable allows you to build browser agents that can navigate sites, fill out forms, clicking buttons and extract information. It is currently at 90.4% on the Web Voyager benchmarks.

It ships as both an npm package (browserable-js) and a self-hosted Docker-based runtime. The runtime includes a web UI for configuration, a tasks API, MongoDB for persistence, and Redis for queuing — giving you a complete local agent infrastructure out of the box.

Setup Workflow

Prerequisites

• Docker
• Docker Compose
• An LLM API key (OpenAI, Anthropic, or Google Gemini)
• A remote browser provider account (Hyperbrowser, Steel, or similar)

Step 1: Install the CLI

The fastest path is the interactive npx command:

npx browserable
```bash

This guides you through setup and opens the admin dashboard at `http://localhost:2001`.

### Step 2: Configure API Keys

Open the admin dashboard at `http://localhost:2001/dash/@admin/settings` and set:

1. An LLM provider API key (choose one: Gemini, OpenAI, or Claude)
2. A remote browser provider API key (Hyperbrowser or Steel — both offer free tiers)

### Step 3: Start the Development Environment

For a full local stack with all services:

```bash
git clone https://github.com/browserable/browserable.git
cd browserable/deployment
docker-compose -f docker-compose.dev.yml up
```bash

This starts all services:

| Service | URL | Description |
|---------|-----|-------------|
| UI Server | http://localhost:2001 | Main interface |
| Documentation | http://localhost:2002 | Local docs |
| Tasks Server | http://localhost:2003 | Task management API |
| MongoDB Express | http://localhost:3300 | Database UI |
| MinIO Console | http://localhost:9001 | Object storage UI |

### Step 4: Use the JavaScript SDK

Install the SDK:

```bash
npm install browserable-js
```bash

Then initialize and use it in your code:

```typescript
import { Browserable } from 'browserable-js';

// Initialize the client
const browser = new Browserable({
  apiKey: process.env.BROWSERABLE_API_KEY,
  remoteBrowserApiKey: process.env.REMOTE_BROWSER_API_KEY,
});

// Navigate and extract
const result = await browser.navigateAndExtract({
  url: 'https://news.ycombinator.com',
  task: 'Find the top 5 stories and their point counts',
});

Deeper Analysis

Architecture: Browserable uses a remote browser provider (Hyperbrowser, Steel) under the hood rather than running Chromium locally. This keeps resource usage low — your server doesn’t need to run a full browser — but means you’re dependent on an external API for the actual browser rendering.

Benchmark performance: The Web Voyager benchmark tests AI agents on real web tasks (shopping, map navigation, forum browsing). Browserable’s 90.4% score puts it competitive with proprietary solutions. For context, OpenAI’s own agent infrastructure scores in the same general range on comparable benchmarks.

SDK availability: Currently JavaScript/TypeScript only (browserable-js on npm). Python and other SDKs appear on the roadmap but aren’t available yet.

Self-hosted: Everything runs on your own infrastructure — no data leaves your network unless you’re using a remote browser provider’s API. This makes it suitable for processing sensitive internal tools.

Practical Evaluation Checklist

• Clone and start with docker-compose.dev.yml
• Configure LLM and browser API keys in the dashboard
• Run a simple navigation task via the SDK
• Verify task results appear in MongoDB
• Test with a login-gated page to check auth handling
• Evaluate response latency vs. direct Playwright scripting

Security Notes

• API keys are stored in the local MongoDB instance — ensure the container is network-isolated
• Remote browser providers (Hyperbrowser, Steel) receive the URLs you navigate to — review their data policies
• No built-in rate limiting or request signing for the Tasks Server in dev config

FAQ

Q: How does Browserable compare to Playwright? A: Playwright is a general-purpose browser automation library; Browserable is purpose-built for LLM-driven agents. Browserable wraps a remote browser provider, abstracts task queuing and result storage, and exposes a natural-language-friendly SDK. Playwright offers more control and broader language support; Browserable offers faster LLM integration.

Q: Do I need a remote browser provider? A: Yes — Browserable requires an external remote browser service (Hyperbrowser or Steel) to handle the actual browser rendering. The local Docker stack runs the orchestration layer (UI, API, database), not Chromium itself.

Q: Is there a hosted version? A: Not currently. Browserable is fully self-hosted. There is no managed cloud offering.

Q: What LLM providers are supported? A: The README mentions OpenAI, Anthropic Claude, and Google Gemini. Configuration is through the admin dashboard.

Source and Accuracy Notes

• Project page: browserable.ai
• Source repository: github.com/browserable/browserable
• License: MIT (verified via GitHub API license.spdx_id)
• Documentation: docs.browserable.ai