How to integrate Browserbase tool MCP with CrewAI

Connect CrewAI to Browserbase tool MCP. Start a new headless browser session now, download all artifacts from last session, and more using natural language, with authentication handled for you.

Browserbase tool logoBrowserbase tool
Api Key

Browserbase is a serverless platform for running and managing headless browsers at scale. It lets you automate and monitor browser tasks with Playwright, Puppeteer, and Selenium—no infrastructure headaches.

64 Tools

Introduction

This guide walks you through connecting Browserbase tool to CrewAI using the Composio tool router. By the end, you'll have a working Browserbase tool agent that can create and manage browser sessions, run Browserbase agents, invoke functions, fetch pages, and download session replays and logs through natural language commands.

This guide will help you understand how to give your CrewAI agent real control over a Browserbase tool account through Composio's Browserbase tool MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

For exact tool slugs and parameter tables, see the tool catalog in the Composio docs.

Also integrate Browserbase tool with

TL;DR

Here's what you'll learn:
  • Get a Composio API key and configure your Browserbase tool connection
  • Set up CrewAI with an MCP enabled agent
  • Create a Tool Router session or standalone MCP server for Browserbase tool
  • Build a conversational loop where your agent can execute Browserbase tool operations

What is CrewAI?

CrewAI is a powerful framework for building multi-agent AI systems. It provides primitives for defining agents with specific roles, creating tasks, and orchestrating workflows through crews.

Key features include:

  • Agent Roles: Define specialized agents with specific goals and backstories
  • Task Management: Create tasks with clear descriptions and expected outputs
  • Crew Orchestration: Combine agents and tasks into collaborative workflows
  • MCP Integration: Connect to external tools through Model Context Protocol

What is the Browserbase tool MCP server, and what's possible with it?

The Browserbase MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Browserbase account. It provides structured and secure access to your browser sessions, contexts, projects, recordings, logs, files, and extensions, so your agent can create sessions, manage reusable contexts, inspect browser activity, retrieve recordings, and monitor project usage on your behalf.

  • Browser session management: Have your agent create isolated browser sessions, check their status, list recent sessions, and release running sessions when work is complete.
  • Reusable browser contexts: Let the agent create, inspect, and update browser contexts that preserve settings across multiple sessions.
  • Session monitoring and debugging: Direct your agent to retrieve live debugging access, review captured network activity, and inspect session logs.
  • Recordings and session artifacts: Instruct your agent to retrieve session replays, request downloadable recordings, and download generated session files.
  • Projects, files, and extensions: Have your agent review projects and usage, upload files for browser forms, and upload or inspect browser extensions.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step08 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Python 3.9 or higher
  • A Composio account and API key
  • A Browserbase tool connection authorized in Composio
  • An OpenAI API key for the CrewAI LLM
  • Basic familiarity with Python
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install dependencies

bash
pip install composio crewai crewai-tools[mcp] python-dotenv
What's happening:
  • composio connects your agent to Browserbase tool via MCP
  • crewai provides Agent, Task, Crew, and LLM primitives
  • crewai-tools[mcp] includes MCP helpers
  • python-dotenv loads environment variables from .env
4

Set up environment variables

bash
COMPOSIO_API_KEY=your_composio_api_key_here
USER_ID=your_user_id_here
OPENAI_API_KEY=your_openai_api_key_here

Create a .env file in your project root.

What's happening:

  • COMPOSIO_API_KEY authenticates with Composio
  • USER_ID scopes the session to your account
  • OPENAI_API_KEY lets CrewAI use your chosen OpenAI model
5

Import dependencies

python
import os
from composio import Composio
from crewai import Agent, Task, Crew
from crewai_tools import MCPServerAdapter
import dotenv

dotenv.load_dotenv()

COMPOSIO_API_KEY = os.getenv("COMPOSIO_API_KEY")
COMPOSIO_USER_ID = os.getenv("COMPOSIO_USER_ID")

if not COMPOSIO_API_KEY:
    raise ValueError("COMPOSIO_API_KEY is not set")
if not COMPOSIO_USER_ID:
    raise ValueError("COMPOSIO_USER_ID is not set")
What's happening:
  • CrewAI classes define agents and tasks, and run the workflow
  • MCPServerHTTP connects the agent to an MCP endpoint
  • Composio will give you a short lived Browserbase tool MCP URL
6

Create a Composio Tool Router session for Browserbase tool

python
composio_client = Composio(api_key=COMPOSIO_API_KEY)
session = composio_client.create(user_id=COMPOSIO_USER_ID, toolkits=["browserbase_tool"])

url = session.mcp.url
What's happening:
  • You create a Browserbase tool only session through Composio
  • Composio returns an MCP HTTP URL that exposes Browserbase tool tools
7

Initialize the MCP Server

python
server_params = {
    "url": url,
    "transport": "streamable-http",
    "headers": {"x-api-key": COMPOSIO_API_KEY},
}

with MCPServerAdapter(server_params) as tools:
    agent = Agent(
        role="Search Assistant",
        goal="Help users search the internet effectively",
        backstory="You are a helpful assistant with access to search tools.",
        tools=tools,
        verbose=False,
        max_iter=10,
    )
What's Happening:
  • Server Configuration: The code sets up connection parameters including the MCP server URL, streamable HTTP transport, and Composio API key authentication.
  • MCP Adapter Bridge: MCPServerAdapter acts as a context manager that converts Composio MCP tools into a CrewAI-compatible format.
  • Agent Setup: Creates a CrewAI Agent with a defined role (Search Assistant), goal (help with internet searches), and access to the MCP tools.
  • Configuration Options: The agent includes settings like verbose=False for clean output and max_iter=10 to prevent infinite loops.
  • Dynamic Tool Usage: Once created, the agent automatically accesses all Composio Search tools and decides when to use them based on user queries.
8

Create a CLI Chatloop and define the Crew

python
print("Chat started! Type 'exit' or 'quit' to end.\n")

conversation_context = ""

while True:
    user_input = input("You: ").strip()

    if user_input.lower() in ["exit", "quit", "bye"]:
        print("\nGoodbye!")
        break

    if not user_input:
        continue

    conversation_context += f"\nUser: {user_input}\n"
    print("\nAgent is thinking...\n")

    task = Task(
        description=(
            f"Conversation history:\n{conversation_context}\n\n"
            f"Current request: {user_input}"
        ),
        expected_output="A helpful response addressing the user's request",
        agent=agent,
    )

    crew = Crew(agents=[agent], tasks=[task], verbose=False)
    result = crew.kickoff()
    response = str(result)

    conversation_context += f"Agent: {response}\n"
    print(f"Agent: {response}\n")
What's Happening:
  • Interactive CLI Setup: The code creates an infinite loop that continuously prompts for user input and maintains the entire conversation history in a string variable.
  • Input Validation: Empty inputs are ignored to prevent processing blank messages and keep the conversation clean.
  • Context Building: Each user message is appended to the conversation context, which preserves the full dialogue history for better agent responses.
  • Dynamic Task Creation: For every user input, a new Task is created that includes both the full conversation history and the current request as context.
  • Crew Execution: A Crew is instantiated with the agent and task, then kicked off to process the request and generate a response.
  • Response Management: The agent's response is converted to a string, added to the conversation context, and displayed to the user, maintaining conversational continuity.

Complete Code

Here's the complete code to get you started with Browserbase tool and CrewAI:

python
from crewai import Agent, Task, Crew, LLM
from crewai_tools import MCPServerAdapter
from composio import Composio
from dotenv import load_dotenv
import os

load_dotenv()

GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
COMPOSIO_API_KEY = os.getenv("COMPOSIO_API_KEY")
COMPOSIO_USER_ID = os.getenv("COMPOSIO_USER_ID")

if not GOOGLE_API_KEY:
    raise ValueError("GOOGLE_API_KEY is not set in the environment.")
if not COMPOSIO_API_KEY:
    raise ValueError("COMPOSIO_API_KEY is not set in the environment.")
if not COMPOSIO_USER_ID:
    raise ValueError("COMPOSIO_USER_ID is not set in the environment.")

# Initialize Composio and create a session
composio = Composio(api_key=COMPOSIO_API_KEY)
session = composio.create(
    user_id=COMPOSIO_USER_ID,
    toolkits=["browserbase_tool"],
)
url = session.mcp.url

# Configure LLM
llm = LLM(
    model="gpt-5",
    api_key=os.getenv("OPENAI_API_KEY"),
)

server_params = {
    "url": url,
    "transport": "streamable-http",
    "headers": {"x-api-key": COMPOSIO_API_KEY},
}

with MCPServerAdapter(server_params) as tools:
    agent = Agent(
        role="Search Assistant",
        goal="Help users with internet searches",
        backstory="You are an expert assistant with access to Composio Search tools.",
        tools=tools,
        llm=llm,
        verbose=False,
        max_iter=10,
    )

    print("Chat started! Type 'exit' or 'quit' to end.\n")

    conversation_context = ""

    while True:
        user_input = input("You: ").strip()

        if user_input.lower() in ["exit", "quit", "bye"]:
            print("\nGoodbye!")
            break

        if not user_input:
            continue

        conversation_context += f"\nUser: {user_input}\n"
        print("\nAgent is thinking...\n")

        task = Task(
            description=(
                f"Conversation history:\n{conversation_context}\n\n"
                f"Current request: {user_input}"
            ),
            expected_output="A helpful response addressing the user's request",
            agent=agent,
        )

        crew = Crew(agents=[agent], tasks=[task], verbose=False)
        result = crew.kickoff()
        response = str(result)

        conversation_context += f"Agent: {response}\n"
        print(f"Agent: {response}\n")

Conclusion

You now have a CrewAI agent connected to Browserbase tool through Composio's Tool Router. The agent can perform Browserbase tool operations through natural language commands.

Next steps:

  • Add role-specific instructions to customize agent behavior
  • Plug in more toolkits for multi-app workflows
  • Chain tasks for complex multi-step operations
TOOLS

Supported Tools

Every Browserbase tool action and event your agent gets out of the box.

Attach Browserbase Function Secret

Attach an existing project secret to a Function by UUID.

Update Browser Context

Tool to update a specific browser context.

Create Browserbase Agent

Create a reusable browser agent with a name and optional system prompt and result schema.

Create Browser Context

Create a reusable browser context; the API key can select the project.

Create Browser Session

Create an isolated Browserbase session and return its connection details.

Create Browserbase Webhook

Register a publicly reachable HTTPS endpoint for project event deliveries.

Delete Browserbase Agent

Delete a reusable browser agent by its agentId.

Delete a browser context

Tool to delete a browser context and all its stored data (cookies, localStorage, etc.).

Delete Download

Delete a download file from storage and mark it as deleted.

Delete a browser extension

Tool to delete an uploaded browser extension by its ID.

Delete Session Downloads

Tool to delete all file downloads from a specific browser session.

Delete Browserbase Webhook

Delete a webhook, immediately stopping deliveries and retiring its secret.

Detach Browserbase Function Secret

Detach a project secret from a Function by UUID.

Download Session Artifacts

Download a completed session's generated files as a ZIP archive.

Fetch Browserbase Page

Fetch a page and return its content, headers, and metadata.

Get Browserbase Agent

Retrieve a reusable browser agent by its agentId.

Get Certificate

Retrieve a Browserbase certificate by its ID.

Get Browser Context

Return metadata for a browser context by ID.

Get Download

Get a single download by ID as metadata or a downloadable file object.

Retrieve a browser extension

Tool to retrieve details of a specific browser extension.

Get Browserbase Function

Retrieve a Browserbase function by its ID.

Get Browserbase Function Build

Retrieve a Browserbase function build by its build ID.

Get Browserbase Function Build Logs

Retrieve Browserbase function build logs by the build ID.

Get Browserbase Function Version

Retrieve a Browserbase function version by its version ID.

Get Browserbase Invocation

Retrieve a Browserbase function invocation by its invocation ID.

Get Browserbase Invocation Logs

Retrieve Browserbase function invocation logs by the invocation ID.

Get Browserbase Keypair

Retrieve the project's public HPKE encryption key and keypair ID.

Get Browserbase Project

Return project metadata, default timeout, and assigned concurrency.

Get project usage statistics

Tool to retrieve usage statistics for a project including browser minutes and proxy bytes consumed.

Get Browserbase Agent Run

Retrieve a browser agent run's current status, result, and session details.

Get Browserbase Secret

Retrieve a project secret's ID and name by UUID, without its secret value.

Get Browser Session

Return status, connection details, and timestamps for a browser session.

Get Session Debug URLs

Return live debugger and WebSocket URLs for a running browser session.

Get Session Logs

Return network request and response events captured during a browser session.

Get Session Replay

Return HLS replay metadata and page playlist paths for a recorded session.

Get Session Replay Page

Return the HLS M3U8 playlist for one recorded replay page.

Get Browserbase Webhook

Retrieve a single webhook by ID, without its signing secret.

Invoke Browserbase Function

Invoke a deployed Browserbase function asynchronously.

List Browserbase Agents

List one page of reusable browser agents across your account.

List Certificates

List Browserbase certificates with their IDs, timestamps, and project IDs.

List Browserbase Downloads

List one page of download metadata for a required browser session.

List Browserbase Function Builds

List one page of Browserbase function builds, optionally filtered by status.

List Browserbase Functions

List one page of Browserbase functions and the total number available.

List Browserbase Function Secrets

List one page of secret IDs and names attached to a Browserbase function, optionally filtered by creation time.

List Browserbase Function Versions

List one page of versions for a Browserbase function by its UUID.

List Browserbase Projects

List projects with their default timeout and assigned concurrency.

List Recording Downloads

Poll per-page MP4 assembly after requesting recording downloads until every page is COMPLETED or FAILED.

List Browserbase Run Messages

List a page of a browser agent run's messages, oldest first, with assistant or tool roles and text or typed content parts.

List Browserbase Agent Runs

List a page of browser agent runs across your account.

List Browserbase Secrets

List one page of project secret IDs and names, optionally filtered by creation time.

List Browser Sessions

List browser sessions, optionally filtered by status or user metadata.

List Browserbase Function Version Invocations

List one page of invocations for a Browserbase function version by its UUID.

List Browserbase Webhooks

List one page of the project's webhooks, newest first, without signing secrets.

Release Browser Session

Irreversibly request release of a running browser session, ending it before its configured timeout to avoid further charges.

Request Recording Downloads

Start asynchronous MP4 assembly for every recorded page of a completed session, then poll List Recording Downloads until every page is COMPLETED or FAILED.

Resume Browserbase Agent Run

Resume only a PAUSED browser agent run with optional additional input.

Run Browserbase Agent

Start a browser agent run to complete a task using web search and browser tools.

Stop Browserbase Agent Run

Request that an in-progress browser agent run stop.

Update Browserbase Agent

Update a reusable browser agent's name, system prompt, or result schema.

Update Browserbase Webhook

Update a webhook's delivery URL, subscribed event types, or both.

Upload Browser Extension

Tool to upload a browser extension for use in sessions.

Upload Session File

Upload one file so browser interactions can select it in a file input field.

Upload Session Files

Upload multiple files to one browser session for file-input interactions.

Web Search

Perform a web search and return structured results.

FAQ

Frequently asked questions

Start with Browserbase tool.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Browserbase tool tool your agent needs.Free to start.

Start building