Browser Use

A Bijection component for Browser Use Cloud - automate browser tasks with AI agents

Markdown ▾

View Markdown Download MarkdownOpen in ChatGPT ↗Open in Claude ↗Open in Perplexity ↗

Bijection source

git clone https://github.com/bijectionhq/browser-use.git
cd browser-use
git checkout 8e37a347fe67379f6160844dd79b0f63ef87e7b2

Bijection repository access is required. Request access.

Description

A Bijection component for Browser Use Cloud - automate browser tasks with AI agents

Explore the package README for API concepts, configuration, and examples. Check the Bijection source for adaptation-specific setup.

Available to evaluate

Review the source and its dependencies before adopting this package. Source availability does not establish npm publication or runtime qualification.

Getting started

Get the source at the revision above and read its package documentation.
Check the required Bijection SDK version, dependencies, and external service credentials.
Follow the package setup instructions and the guide to using components.
Exercise the component in your deployment according to your project’s verification rules.

Open source

Maintained source: bijectionhq/browser-use. Based on Cheggin/browser-use-convex-component. License: MIT. Consult the repository for license terms, notices, and contributor attribution.

From the upstream publisher

A Convex component for Browser Use Cloud - automate browser tasks with AI agents

Explore the demo ↗

Upstream overview

From the upstream package documentation.

This component integrates Browser Use Cloud's AI-powered browser automation API with Convex's reactive database. It provides persistent task tracking, session management, and browser profile storage while enabling real-time queries on automation status. Developers get a full-stack solution for browser automation with reactive subscriptions to task progress and results.

Use cases

From the upstream package documentation.

Web scraping workflows where you need to track long-running scraping tasks and reactively update your UI as data is collected
E2E testing automation that requires persistent browser sessions across multiple test runs with profile-based authentication
User onboarding automation where you guide users through complex web flows and need to monitor completion status in real-time
Content management tasks like bulk social media posting or form submissions that benefit from visual element highlighting and structured output
Competitive analysis tools that automate data collection from multiple domains with proxy rotation and session persistence

How it works

From the upstream package documentation.

The component wraps the Browser Use Cloud API in Convex actions while storing all task, session, and profile data in your Convex database. You initialize the BrowserUse client with your component's API surface, then call methods like createTask() to start browser automation jobs that persist their status locally.

Tasks support comprehensive configuration including AI model selection, structured JSON output schemas, domain restrictions, and custom secrets injection. The component provides both actions for API calls (like fetchTaskStatus()) and queries for reactive data access (like listTasks() and getTaskSteps()), enabling real-time UI updates as automation progresses.

Session and profile management enables persistent browser states across automation runs. Sessions can use proxy rotation and country-specific routing, while profiles store authentication cookies and browser preferences. All data flows through Convex's reactive system, so your frontend automatically updates when task status changes or new automation results arrive.

Upstream package FAQ

What browser automation capabilities does this component provide?

The Browser Use Convex Component wraps the Browser Use Cloud API to provide AI-powered browser automation including page navigation, form filling, clicking elements, and data extraction. All tasks are managed through Convex functions with persistent storage and real-time monitoring capabilities.

How does session management work with browser profiles?

The component provides functions to create and manage persistent browser sessions with profile support, allowing you to maintain authentication state and cookies across automation runs. Sessions can be configured with proxy settings and are stored in Convex for persistence between tasks.

Can I monitor browser automation tasks in real-time?

Yes, the Browser Use Convex Component stores all task data in Convex, enabling real-time subscriptions to task status, progress, and results. Your frontend can reactively update as automation tasks execute, providing live feedback to users.

What happens if a browser automation task fails?

The Browser Use Convex Component handles task failures by storing error information in Convex, allowing you to query failed tasks and their error details. You can implement retry logic using Convex's scheduling system and monitor task health through reactive queries.

Do I need a Browser Use Cloud API key?

Yes, the Browser Use Convex Component requires a Browser Use Cloud API key to function, as it wraps their browser automation service. The component handles API communication while providing Convex-native functions for task and session management with persistent storage.

Use with agents and CLI

View Skill

Give your coding agent the component’s source identity and setup guidance.

agent-prompt.md

Help me integrate Browser Use with Bijection.

Read: https://bijection.com/components/browser-use/SKILL.md

Check SDK compatibility and dependency availability.
Follow this project's execution and verification rules.

Download SKILL.md llms.txt

Upstream README.md

View repository ↗

Documentation from Cheggin/browser-use-convex-component, recorded October 23, 2026. APIs and setup may differ in the Bijection adaptation.

Browser Use Convex Component

A Convex component that wraps the Browser Use Cloud API, enabling AI-powered browser automation with persistent task tracking, session management, and reactive queries.

Features

Task Management - Create, monitor, and stop browser automation tasks
Session Management - Create persistent browser sessions with proxy support
Profile Management - Manage browser profiles for authentication persistence
Reactive Queries - All task and session data stored in Convex for real-time subscriptions

Installation

npm install browser-use-convex-component

Setup

1. Configure your app

In your convex/convex.config.ts:

import { defineApp } from "convex/server";
import browserUse from "browser-use-convex-component/convex.config.js";

const app = defineApp();
app.use(browserUse);

export default app;

2. Set your API key

Set the BROWSER_USE_API_KEY environment variable in your Convex deployment:

npx convex env set BROWSER_USE_API_KEY bu_your_api_key_here

Usage

Initialize the client

import { BrowserUse } from "browser-use-convex-component";
import { components } from "./_generated/api.js";

const browserUse = new BrowserUse(components.browserUse);

Create a task

export const startTask = action({
  args: { task: v.string() },
  returns: v.any(),
  handler: async (ctx, args) => {
    const { taskId, externalId } = await browserUse.createTask(ctx, {
      task: args.task,
      startUrl: "https://example.com",
    });
    return { taskId, externalId };
  },
});

Query tasks reactively

export const listTasks = query({
  args: {},
  returns: v.any(),
  handler: async (ctx) => {
    return await browserUse.listTasks(ctx);
  },
});

Check task status

export const checkTask = action({
  args: { externalId: v.string() },
  returns: v.any(),
  handler: async (ctx, args) => {
    return await browserUse.fetchTaskStatus(ctx, args);
  },
});

Session management

export const createSession = action({
  args: {},
  returns: v.any(),
  handler: async (ctx) => {
    return await browserUse.createSession(ctx, {
      proxyCountryCode: "us",
    });
  },
});

Profile management

export const listProfiles = action({
  args: {},
  returns: v.any(),
  handler: async (ctx) => {
    return await browserUse.listProfiles(ctx);
  },
});

API Reference

Tasks

Method	Type	Description
`createTask(ctx, args)`	Action	Create a browser automation task
`getTask(ctx, { taskId })`	Query	Get task from local DB
`listTasks(ctx, opts?)`	Query	List tasks with optional filters
`getTaskSteps(ctx, { taskId })`	Query	Get step-by-step execution details
`fetchTaskStatus(ctx, { externalId })`	Action	Fetch latest status from API
`fetchTaskDetail(ctx, { externalId })`	Action	Fetch full details and steps from API
`stopTask(ctx, { externalId })`	Action	Stop a running task

Sessions

Method	Type	Description
`createSession(ctx, args?)`	Action	Create a browser session
`getSession(ctx, { sessionId })`	Query	Get session from local DB
`listSessions(ctx, opts?)`	Query	List sessions with optional filters
`fetchSessionDetail(ctx, { externalId })`	Action	Fetch session details from API
`stopSession(ctx, { externalId })`	Action	Stop a session

Profiles

Method	Type	Description
`createProfile(ctx, args?)`	Action	Create a browser profile
`listProfiles(ctx)`	Action	List all profiles
`getProfile(ctx, { profileId })`	Action	Get profile details
`updateProfile(ctx, { profileId, name })`	Action	Update profile name
`deleteProfile(ctx, { profileId })`	Action	Delete a profile

Task Options

Option	Type	Description
`task`	`string`	The instruction for the AI agent (required)
`llm`	`string`	AI model (default: `browser-use-2.0`)
`sessionId`	`string`	Existing session to use
`startUrl`	`string`	Initial URL to navigate to
`maxSteps`	`number`	Max execution steps (default: 100)
`flashMode`	`boolean`	Accelerated execution mode
`thinking`	`boolean`	Extended reasoning
`vision`	`boolean \| "auto"`	Visual recognition
`highlightElements`	`boolean`	Highlight interactive elements
`systemPromptExtension`	`string`	Append to the system prompt
`structuredOutput`	`object`	JSON schema for response formatting
`secrets`	`object`	Secure key-value data injection
`allowedDomains`	`string[]`	Navigation restrictions
`metadata`	`object`	Custom tracking pairs
`judge`	`boolean`	AI-powered success validation
`judgeGroundTruth`	`string`	Ground truth for judge evaluation
`judgeLlm`	`string`	Model for judge evaluation
`skillIds`	`string[]`	Pre-built skill IDs to use