Tutorial Browser-Use: Automasi Browser dengan AI Agent

Pendahuluan

Browser-Use adalah library Python open-source yang memungkinkan Large Language Model (LLM) mengontrol browser web secara otonom. Dengan Browser-Use, Anda dapat membangun AI agent yang mampu menavigasi halaman web, mengisi form, mengekstrak data, dan menjalankan tugas-tugas kompleks di browser layaknya manusia.

Library ini menjembatani gap antara kemampuan reasoning LLM dengan interaksi dunia nyata melalui browser. Berbeda dengan web scraping tradisional yang membutuhkan selector CSS atau XPath yang rapuh, Browser-Use memanfaatkan kemampuan vision dan reasoning LLM untuk memahami halaman web secara visual dan semantik.

Beberapa use case populer Browser-Use meliputi:

• Web Research Agent: Otomatis mencari dan mengumpulkan informasi dari berbagai sumber
• Form Automation: Mengisi formulir web secara otomatis
• Testing Agent: Melakukan pengujian UI secara otomatis
• Data Extraction: Mengekstrak data terstruktur dari halaman web
• Workflow Automation: Mengotomasi alur kerja yang melibatkan banyak langkah di browser

Dalam tutorial ini, kita akan membahas cara instalasi, penggunaan dasar, teknik lanjutan, serta best practices dalam menggunakan Browser-Use untuk membangun AI browser agent yang andal.

Instalasi

Prasyarat

Sebelum menginstal Browser-Use, pastikan Anda memiliki:

• Python 3.11 atau lebih baru
• pip atau uv sebagai package manager
• API key dari provider LLM (OpenAI, Anthropic, atau lainnya)

Instalasi dengan pip

pip install browser-use

Instalasi dengan uv (Rekomendasi)

uv pip install browser-use

Instal Playwright Browser

Browser-Use menggunakan Playwright sebagai engine browser. Setelah instalasi, jalankan:

playwright install chromium

Setup Environment Variables

Buat file .env di root project Anda:

OPENAIAPIKEY=sk-your-openai-key
ANTHROPICAPIKEY=sk-ant-your-anthropic-key

Verifikasi Instalasi

import browseruse
print(f"Browser-Use version: {browseruse.version}")

Penggunaan Dasar

Agent Pertama Anda

Berikut contoh paling sederhana untuk membuat browser agent:

import asyncio
from browseruse import Agent

from langchainopenai import ChatOpenAI

async def main():
    agent = Agent(
        task="Cari harga Bitcoin hari ini di Google dan berikan hasilnya",
        llm=ChatOpenAI(model="gpt-4o"),
    )
    result = await agent.run()
    print(result)

asyncio.run(main())

Agent akan membuka browser, navigasi ke Google, mencari harga Bitcoin, dan mengembalikan hasilnya.

Menggunakan Anthropic Claude

Browser-Use mendukung berbagai provider LLM. Berikut contoh menggunakan Claude:

import asyncio
from browseruse import Agent

from langchainanthropic import ChatAnthropic

async def main():
    agent = Agent(
        task="Buka Wikipedia dan cari informasi tentang Machine Learning",
        llm=ChatAnthropic(model="claude-sonnet-4-20250514"),
    )
    result = await agent.run()
    print(result)

asyncio.run(main())

Menjalankan dengan Browser Visible

Secara default, browser berjalan dalam mode headless. Untuk melihat apa yang dilakukan agent:

import asyncio
from browseruse import Agent, Browser, BrowserConfig

from langchainopenai import ChatOpenAI

async def main():
    browser = Browser(
        config=BrowserConfig(
            headless=False,  # Browser terlihat
        )
    )

    agent = Agent(
        task="Navigasi ke GitHub dan cari repository browser-use",
        llm=ChatOpenAI(model="gpt-4o"),
        browser=browser,
    )
    result = await agent.run()
    print(result)
    await browser.close()

asyncio.run(main())

Mengekstrak Data Terstruktur

Gunakan Pydantic model untuk mendapatkan output terstruktur:

import asyncio
from pydantic import BaseModel
from browseruse import Agent

from langchainopenai import ChatOpenAI

class ProductInfo(BaseModel):
    name: str
    price: str
    rating: str
    description: str

async def main():
    agent = Agent(
        task="Buka tokopedia.com dan cari laptop gaming terpopuler. Ambil informasi produk pertama.",
        llm=ChatOpenAI(model="gpt-4o"),
        returntype=ProductInfo,

    )
    result = await agent.run()
    print(f"Nama: {result.name}")
    print(f"Harga: {result.price}")
    print(f"Rating: {result.rating}")

asyncio.run(main())

import asyncio
from browseruse import Agent, Controller
from langchainopenai import ChatOpenAI


controller = Controller()

@controller.action("Simpan data ke file CSV")
def savetocsv(data: str, filename: str):

    """Simpan data yang diekstrak ke file CSV"""
    import csv
    rows = [row.split(",") for row in data.strip().split("\n")]
    with open(filename, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerows(rows)
    return f"Data berhasil disimpan ke {filename}"

@controller.action("Kirim notifikasi")
def sendnotification(message: str):
    """Kirim notifikasi setelah tugas selesai"""
    print(f"NOTIFIKASI: {message}")
    return "Notifikasi terkirim"

async def main():
    agent = Agent(
        task="""
        Buka harga.com dan cari daftar harga laptop Lenovo.
        Ambil 5 produk teratas dengan nama dan harga.
        Simpan ke file CSV bernama 'laptopprices.csv'.

        Kirim notifikasi bahwa tugas selesai.
        """,
        llm=ChatOpenAI(model="gpt-4o"),
        controller=controller,
    )
    result = await agent.run()
    print(result)

asyncio.run(main())

import asyncio
from browseruse import Agent, Browser, BrowserConfig, BrowserContextConfig
from langchainopenai import ChatOpenAI


async def main():
    browser = Browser(
        config=BrowserConfig(
            headless=False,
            chromeinstancepath="/usr/bin/google-chrome",

        )
    )

    contextconfig = BrowserContextConfig(
        cookiesfile="cookies.json",

        waitfornetworkidlepageloadtime=3.0,

        browserwindowsize={"width": 1280, "height": 720},

        locale="id-ID",
        timezoneid="Asia/Jakarta",
    )

    context = await browser.newcontext(config=contextconfig)

    agent = Agent(
        task="Login ke dashboard dan download laporan bulanan",
        llm=ChatOpenAI(model="gpt-4o"),
        browsercontext=context,

    )
    result = await agent.run()
    await browser.close()

asyncio.run(main())

import asyncio
from browseruse import Agent
from langchainopenai import ChatOpenAI


async def main():
    agent = Agent(
        task="""
Buka tab pertama ke google.com dan cari "Python tutorial"
Buka tab baru ke stackoverflow.com dan cari "Python best practices"
Bandingkan hasil dari kedua sumber
Berikan ringkasan gabungan dari kedua sumber
        """,
        llm=ChatOpenAI(model="gpt-4o"),
        maxactionsperstep=5,
    )
    result = await agent.run()
    print(result)

asyncio.run(main())

Menangani Captcha dan Anti-Bot

Untuk situs dengan proteksi anti-bot:

import asyncio
from browseruse import Agent, Browser, BrowserConfig

from langchainopenai import ChatOpenAI

async def main():
    browser = Browser(
        config=BrowserConfig(
            headless=False,
            disablesecurity=False,

            extrachromiumargs=[

                "--disable-blink-features=AutomationControlled",
            ],
        )
    )

    agent = Agent(
        task="Navigasi ke situs target dan ekstrak data yang diperlukan",
        llm=ChatOpenAI(model="gpt-4o"),
        browser=browser,
        maxfailures=5,
        retrydelay=2,

    )
    result = await agent.run()
    await browser.close()

asyncio.run(main())

import asyncio
from browseruse import Agent
from langchainopenai import ChatOpenAI

from langchaincore.messages import HumanMessage, SystemMessage

async def main():
    systemmessage = SystemMessage(

        content="""Kamu adalah asisten riset yang teliti.
        Selalu verifikasi informasi dari minimal 2 sumber berbeda.
        Berikan jawaban dalam bahasa Indonesia yang jelas dan terstruktur."""
    )

    agent = Agent(
        task="""
        Riset tentang tren AI di Indonesia tahun 2026:
Cari artikel terbaru tentang adopsi AI di perusahaan Indonesia
Cari data statistik penggunaan AI di Asia Tenggara
Buat ringkasan temuan
        """,
        llm=ChatOpenAI(model="gpt-4o"),
        systempromptclass=None,

        messagecontext=[systemmessage],

        maxactionsperstep=3,
    )
    result = await agent.run(maxsteps=25)

    print(result)

asyncio.run(main())

import asyncio
from browseruse import Agent
from langchainopenai import ChatOpenAI


async def researchtopic(topic: str):
    agent = Agent(
        task=f"Cari informasi terbaru tentang {topic} dan buat ringkasan singkat",
        llm=ChatOpenAI(model="gpt-4o"),
    )
    return await agent.run()

async def main():
    topics = [
        "perkembangan LLM terbaru",
        "framework AI agent 2026",
        "computer vision trends",
    ]

    results = await asyncio.gather(
        [researchtopic(topic) for topic in topics]

    )

    for topic, result in zip(topics, results):
        print(f"\n{'='50}")
        print(f"Topik: {topic}")
        print(f"Hasil: {result}")

asyncio.run(main())

import asyncio
from browseruse import Agent, Browser, BrowserConfig, BrowserContextConfig
from langchainopenai import ChatOpenAI


async def main():
    contextconfig = BrowserContextConfig(
        savedownloadspath="./downloads",
    )

    browser = Browser(config=BrowserConfig(headless=False))
    context = await browser.newcontext(config=contextconfig)

    agent = Agent(
        task="""
        Buka GitHub releases page untuk project browser-use.
        Download file source code zip dari release terbaru.
        """,
        llm=ChatOpenAI(model="gpt-4o"),
        browsercontext=context,

    )
    result = await agent.run()
    await browser.close()

asyncio.run(main())

agent = Agent(
    task="Tugas Anda di sini",
    llm=ChatOpenAI(model="gpt-4o"),
    maxactionsperstep=10,
    usevision=True,

    maxfailures=3,
    retrydelay=1,

    toolcallingmethod="auto",

    maxinputtokens=128000,

    generategif=True,
)

Penjelasan parameter:

| Parameter | Default | Deskripsi |

|-----------|---------|-----------|

| maxactionsperstep | 10 | Jumlah aksi maksimal per langkah |

| usevision | True | Gunakan screenshot untuk memahami halaman |

| maxfailures | 3 | Toleransi kegagalan sebelum berhenti |

| retrydelay | 1 | Delay (detik) antara retry |

| generategif | False | Generate GIF rekaman aksi agent |

| maxinputtokens | 128000 | Batas token input ke LLM |

config = BrowserConfig(
    headless=True,
    disablesecurity=False,
    extrachromiumargs=["--no-sandbox"],
    chromeinstancepath=None,
    wssurl=None,

    proxy={
        "server": "http://proxy:8080",
        "username": "user",
        "password": "pass",
    },
)

# Kurang baik
agent = Agent(task="Cari data", llm=llm)

Lebih baik
agent = Agent(
    task="""
    Buka website BPS (bps.go.id) dan cari data inflasi Indonesia
    untuk bulan Januari-Juni 2026. Catat angka inflasi bulanan
    dan year-on-year. Jika data tidak tersedia, catat sebagai N/A.
    """,
    llm=llm,
)

import asyncio
from browseruse import Agent
from langchainopenai import ChatOpenAI


async def main():
    agent = Agent(
        task="Tugas yang mungkin gagal",
        llm=ChatOpenAI(model="gpt-4o"),
        maxfailures=5,
    )

    try:
        result = await agent.run(maxsteps=30)

        if result:
            print(f"Berhasil: {result}")
        else:
            print("Agent selesai tanpa hasil")
    except Exception as e:
        print(f"Error: {e}")

asyncio.run(main())

agent = Agent(
    task="Tugas Anda",
    llm=ChatOpenAI(model="gpt-4o"),
    usevision=False,  # Nonaktifkan jika tidak perlu vision
    maxactionsperstep=3,  # Batasi aksi per step

    maxinputtokens=64000,  # Batasi context window

)

import logging
logging.basicConfig(level=logging.DEBUG)

import asyncio
from browseruse import Agent
from langchainopenai import ChatOpenAI


async def main():
    agent = Agent(
        task="Tugas dengan logging detail",
        llm=ChatOpenAI(model="gpt-4o"),
        generategif=True,  # Rekam aksi sebagai GIF
    )
    result = await agent.run()
    print(result)

asyncio.run(main())

5. Selalu Tutup Browser

import asyncio
from browseruse import Agent, Browser, BrowserConfig

from langchainopenai import ChatOpenAI

async def main():
    browser = Browser(config=BrowserConfig(headless=True))
    try:
        agent = Agent(
            task="Tugas Anda",
            llm=ChatOpenAI(model="gpt-4o"),
            browser=browser,
        )
        result = await agent.run()
        print(result)
    finally:
        await browser.close()

asyncio.run(main())

6. Batasi Scope Tugas

Pecah tugas besar menjadi sub-tugas yang lebih kecil:

import asyncio
from browseruse import Agent

from langchainopenai import ChatOpenAI

async def step1search():

    agent = Agent(
        task="Buka Google dan cari 'top Python libraries 2026'. Catat 5 hasil teratas.",
        llm=ChatOpenAI(model="gpt-4o"),
    )
    return await agent.run()

async def step2detail(libraryname: str):

    agent = Agent(
        task=f"Buka PyPI dan cari library {libraryname}. Catat versi terbaru, jumlah download, dan deskripsi singkat.",
        llm=ChatOpenAI(model="gpt-4o"),
    )
    return await agent.run()

async def main():
    searchresults = await step1search()
    print(f"Hasil pencarian: {searchresults}")


asyncio.run(main())

• Jangan pernah memasukkan credential langsung di kode
• Gunakan environment variables untuk API keys
• Hati-hati dengan situs yang memiliki terms of service ketat
• Monitor penggunaan token LLM untuk kontrol biaya
• Jangan gunakan disablesecurity=True di production

Perbandingan dengan Tools Serupa

| Fitur | Browser-Use | Playwright (Manual) | Selenium |

|-------|-------------|--------------------:|----------|

| AI-Powered | Ya | Tidak | Tidak |

| Setup Complexity | Rendah | Sedang | Tinggi |

| Adaptif terhadap UI changes | Ya | Tidak | Tidak |

| Perlu selector CSS/XPath | Tidak | Ya | Ya |

| Biaya operasional | LLM API cost | Gratis | Gratis |

| Cocok untuk tugas dinamis | Ya | Tidak | Tidak |

Kesimpulan

Browser-Use membuka paradigma baru dalam automasi browser. Alih-alih menulis script yang rapuh dengan CSS selector, Anda cukup mendeskripsikan tugas dalam bahasa natural dan membiarkan LLM menangani navigasi dan interaksi.

Poin-poin penting dari tutorial ini:

Untuk memulai, coba buat agent sederhana yang mencari informasi di web. Setelah familiar, eksplorasi fitur lanjutan seperti custom actions dan parallel agents untuk membangun workflow automasi yang lebih kompleks.

Kunjungi repository GitHub Browser-Use untuk dokumentasi lengkap dan contoh-contoh tambahan. Selamat mencoba dan semoga tutorial ini bermanfaat untuk proyek automasi Anda.