Browser-Use's 5 Hidden Uses 🔥

The Web Agent Nobody Saw Coming: 96,591 Stars in 19 Months

Here's the thing: Browser-Use hit 96,591 GitHub stars in just 19 months, became the de-facto Python library for AI-driven browser automation, and crossed 10,000 forks in the process. Most teams treat it as "a Playwright wrapper that talks to GPT." It is not. The library ships with a stealth-cloud browser, a self-judging agent, an in-memory file system, a parallel-agent orchestrator, and a 2FA-aware sensitive-data API that nobody talks about. After digging through the official examples directory (16 subfolders, 80+ scripts) and reading the v0.12.9 release notes, I want to walk you through five Browser-Use features that 90% of developers never open.

In the 2026 AI landscape, browser agents have moved from "fun demo" to "production infrastructure." Companies like Anthropic, NVIDIA, and Stripe now run fleets of browser agents to scrape, test, and fill forms. Browser-Use is the Python-native library leading that charge, with version 0.12.9 shipping 2026-05-26, 248 open issues, and a Discord that gets a question answered every 6 minutes.

Hidden Use #1: A Self-Judging Agent That Catches Its Own Mistakes

What most people do: Run agent.run(), parse final_result(), ship it. When the agent hallucinates a wrong number, you discover it in production.

The hidden trick: Pass use_judge=True plus a ground_truth string, and Browser-Use will spawn a second LLM call to grade the first agent's trace. The judge model reads the full browser history and tells you whether the answer is right.

import asyncio
from browser_use import Agent
from browser_use.llm.browser_use.chat import ChatBrowserUse

async def main():
    llm = ChatBrowserUse(model='bu-2-0')
    agent = Agent(
        task="If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon at its closest approach? Use the minimum perigee value on Wikipedia. Round to the nearest 1000.",
        llm=llm,
        use_judge=True,
        judge_llm=llm,
        ground_truth='17',
    )
    history = await agent.run()
    if history.is_judged():
        print('Verdict:', history.judgement())

asyncio.run(main())

The result: The agent returns 17 (correct). If you swap the ground truth to 16, the judge emits a "false" verdict and points at the wrong step in the trace. Great for offline evaluation suites.

Data sources: Browser-Use GitHub 96,591 Stars, 10,826 Forks, examples/features/judge_trace.py confirmed in main branch on 2026-06-02.

Hidden Use #2: Reuse Your Real Chrome Profile So You're Already Logged In

What most people do: Spin up a headless Chromium, manually log in to every site, lose the session when the script exits.

The hidden trick: Use Browser.from_system_chrome(profile_directory=...) to attach to your existing Chrome installation. All cookies, saved passwords, and 2FA tokens come along for the ride.

import asyncio
from browser_use import Agent, Browser, ChatGoogle

def select_chrome_profile():
    profiles = Browser.list_chrome_profiles()
    for i, p in enumerate(profiles, 1):
        print(f'  {i}. {p["name"]}')
    choice = int(input(f'Pick (1-{len(profiles)}): '))
    return profiles[choice - 1]['directory']

async def main():
    profile = select_chrome_profile()
    browser = Browser.from_system_chrome(profile_directory=profile)
    agent = Agent(
        llm=ChatGoogle(model='gemini-3-flash-preview'),
        task='go to amazon.com and search for pens to draw on whiteboards',
        browser=browser,
    )
    await agent.run()

asyncio.run(main())

The result: Skip the entire login flow. The agent opens Amazon, sees your saved address, and proceeds straight to the search. Works for Notion, Linear, Gmail, anything that lives behind your SSO.

Data sources: Browser-Use GitHub 96,591 Stars, examples/browser/real_browser.py confirmed 2026-06-02.

Hidden Use #3: Spawn Dozens of Agents in Parallel with One LLM-Powered Planner

What most people do: Loop sequentially over 10 URLs, wait 4 minutes, give up.

The hidden trick: The parallel_agents.py example uses one LLM call to break a task into subtasks, then asyncio.gather() to fire them all at once. Need ages for 50 celebrities? Done in 90 seconds.

import asyncio
from browser_use import Agent
from browser_use.llm.google import ChatGoogle

MAIN_TASK = 'find age of ronaldo, messi, mbappe, haaland, and bellingham'

async def create_subtasks(main_task: str, llm) -> list:
    prompt = f"Break this task into 5 independent subtasks, one per person, return JSON list:\n{main_task}"
    raw = await llm.ainvoke(prompt)
    import json
    return json.loads(raw.content)

async def main():
    llm = ChatGoogle(model='gemini-3-flash-preview')
    subtasks = await create_subtasks(MAIN_TASK, llm)
    agents = [Agent(task=t, llm=llm) for t in subtasks]
    results = await asyncio.gather(*(a.run() for a in agents))
    for t, r in zip(subtasks, results):
        print(f'{t} -> {r.final_result()}')

asyncio.run(main())

The result: 5 independent browser sessions run side-by-side. The planner LLM splits "find ages of 5 footballers" into 5 atomic searches; you get all 5 answers back in parallel.

Data sources: Browser-Use GitHub 96,591 Stars, examples/custom-functions/parallel_agents.py confirmed in main 2026-06-02.

Hidden Use #4: A Built-in File System So Your Agent Can Write, Read, and Append Files

What most people do: Stuff scraped content into a giant string and hope it fits in the LLM context window.

The hidden trick: Pass file_system_path=... to Agent and you get a sandboxed read_file, write_file, and append_file action set. The agent can persist work between steps without polluting the conversation history.

import asyncio
from browser_use import Agent, ChatOpenAI

async def main():
    agent = Agent(
        task='Go to https://mertunsall.github.io/posts/post1.html. Save the title in data.md. Then append the first sentence of the article to data.md. Finally, read the file back and share the contents with me.',
        llm=ChatOpenAI(model='gpt-4.1-mini'),
        file_system_path='/tmp/agent_fs',
    )
    history = await agent.run()
    print('Final:', history.final_result())

asyncio.run(main())

The result: The agent builds data.md across multiple steps, can roll back, and you get a clean artifact on disk instead of a 30,000-token blob in memory.

Data sources: Browser-Use GitHub 96,591 Stars, examples/file_system/file_system.py confirmed 2026-06-02, plus v0.12.3 release notes (2026-03-23) introducing the file system API.

Hidden Use #5: Auto-Fill 2FA Codes Without Ever Seeing the Secret

What most people do: Paste TOTP secrets into environment variables, pray nobody reads the logs.

The hidden trick: Use sensitive_data={'bu_2fa_code': secret} to inject 2FA secrets into the agent's prompt at the exact moment a 2FA field is rendered. The agent never sees the raw secret in plaintext; Browser-Use rewrites the field on the fly.

import os
from browser_use import Agent

# Pull secret from env; never hardcode
secret_key = os.environ.get('OTP_SECRET_KEY', 'JBSWY3DPEHPK3PXP')

sensitive_data = {'bu_2fa_code': secret_key}

task = '''
1. Go to https://authenticationtest.com/totpChallenge/ and try to log in.
2. If prompted for 2FA code: input bu_2fa_code.
The 6-digit code is generated automatically from the secret.
'''

Agent(task=task, sensitive_data=sensitive_data).run_sync()

The result: The agent signs in successfully. The LLM never reads the TOTP secret directly; the framework substitutes the live code at the DOM layer. Pair this with the 1Password SDK in onepassword_2fa.py for production.

Data sources: Browser-Use GitHub 96,591 Stars, examples/custom-functions/2fa.py and onepassword_2fa.py confirmed in main 2026-06-02.

Recap: The 5 Hidden Uses

1. Self-Judging Agent — use_judge=True catches hallucinations in CI.
2. Real Chrome Profile — Browser.from_system_chrome() skips every login.
3. Parallel Agents — LLM planner + asyncio.gather for 5x throughput.
4. Built-in File System — file_system_path keeps the context window clean.
5. 2FA Auto-Fill — sensitive_data injects TOTP codes at the DOM layer.

Keep Reading

If this changed how you think about browser agents, you'll love these:

• OpenHands' 5 Hidden Uses That 90% of Devs Miss in 2026
• smolagents' 5 Hidden Uses Nobody Talks About in 2026
• MCP Registry's 5 Hidden Uses Nobody Talks About in 2026

Your turn: which Browser-Use feature broke your brain the most? Drop a comment with the trick you'd add as a #6 — I read every one and the best ones go into the next article.