Open-source · MIT license · zero dependencies

Browser automation that works on the sites
that hate it.

OpenBrowser is a Chrome extension plus a zero-dependency MCP server that lets any AI agent — Claude Code, opencode, Cursor — drive your real browser. Your logins, your cookies, real trusted input events. No headless instance, no install step.

View on GitHub
Works with any MCP client
Claude Code opencode Cursor Windsurf Zed your own
app.example.com/login 

        
        
      

    


    
    

      

        0
        tools, grouped by action
      

      

        0
        cheaper reads than screenshots
      

      

        0
        chars to read a full page
      

      

        0
        npm dependencies
      

    

  


  
  

    

      Why OpenBrowser
      
Built for the cases that
break automation

      
Every design decision here came from a real failure on a real site — payment forms that ignore synthetic clicks, iframes three levels deep, pages that cost 4,000 tokens to read.

    


    

      

        

          
        

        
Your real browser, your real session

        
Runs in the Chrome you already use — logged in, configured, extensions installed. No separate headless instance to keep signed in.

      


      

        

          
        

        
Trusted input events

        
Clicks and keystrokes go through the Chrome debugger, so they carry isTrusted: true. Sites that reject synthetic events — Stripe, Google, drag-and-drop — simply work.

      


      

        

          
        

        
Reads that cost ~20x less

        
Pages become a compact accessibility tree with actionable refs — ~350 characters instead of ~4,000 tokens of raw DOM or a screenshot.

      


      

        

          
        

        
Parallel by default

        
Every tool takes a tabId. Fan one call across twenty tabs, and watch them collect into labelled, colour-coded Chrome tab groups.

      


      

        

          
        

        
Zero dependencies

        
Hand-written WebSocket and MCP implementations. No npm install to break, nothing to build. Node 18+ and Chrome 116+ is the whole requirement.

      


      

        

          
        

        
Retroactive capture

        
Console and network activity are recorded continuously into ring buffers, so browser_inspect answers questions about bugs that already happened — no reproduction needed.

      

    

  


  
  

    

      Token cost
      
What an agent sees when
it looks at your page

      
The design assumes tokens are the scarce resource. A 6,000-element page becomes ~350 characters of tree — with every element directly actionable.

    


    

      

      

        

          
          browser_snapshot — mode: "diff"
        

        
app.example.com/login · "Sign in · Example" · tab 481 · 1280x800
banner
  link "Example" [e1] /
main
  heading "Sign in" h1
  form
    textbox "Email" [e2] required
    password "Password" [e3] required
    checkbox "Remember me" [e4] unchecked
    button "Sign in" [e5]
  link "Forgot your password?" [e6] /reset

        

          ⚡ refs are directly actionable — click [e5] to sign in
          356 chars
        

      

    


    

      

        
Diff mode in loops

        
After the first snapshot, ask only for what changed — perfect for watching a status flip or a list populate.

      

      

        
Actions return their own delta

        
After a click you usually already know what changed, so no follow-up snapshot is needed. The single largest token saving in the design.

      

      

        
One batch, many round trips saved

        
browser_batch collapses a whole login into one call. browser_macro replays a flow forever for the cost of one call.

      

    

  


  
  

    

      Architecture
      
One browser, shared
by any agent

      
The first MCP server to start binds the hub port; later ones join it as peers. Several agents can work in the same session without fighting over the browser.

    


    
  


  
  

    

      The tools
      
Fourteen tools.
No forty.

      
Tools are grouped by action enums rather than split into dozens of single-purpose ones — models pick an enum value far more reliably.

    


    

      browser_tabslist · new · close · group
      browser_navigateURL · back · forward · reload
      browser_snapshota11y tree with [ref] handles
      browser_findelements by description, ranked
      browser_actclick · hover · drag · select
      browser_inputtype · fill many fields · keys
      browser_screenshotregion · full page · GIF
      browser_wait9 conditions, never sleeps
      browser_evalrun JavaScript in the page
      browser_inspectconsole · network · storage
      browser_batchmany calls, one round trip
      browser_uploadfiles, even hidden inputs
      browser_windowemulate · throttle · dark mode
      browser_macrosave & replay flows
    

  


  
  

    

      Capabilities
      
What the combination
can actually do

      
Fourteen tools is a small surface. The interesting things come from how they combine — and all of this is real behaviour in the current build, not a roadmap.

    


    

      

        01
        

          
Drive many sites at once, from one call

          
browser_batch with a parallel array fans a sequence of steps across N tabs concurrently, results labelled per tab. Each workstream gets a coloured Chrome tab group, so a human watching the tab strip sees three labelled jobs instead of a wall.

        

        parallel
      

      

        02
        

          
Record a flow once, replay it forever

          
browser_macro saves a step sequence with {{placeholders}} and replays it for the cost of a single call. Re-deriving a login or a search-and-extract flow means five calls and reasoning; replaying it is one call and none.

        

        macros
      

      

        03
        

          
Retroactive console and network capture

          
Ring buffers record from the moment a tab is touched, so browser_inspect answers questions about something that already went wrong — including CSP violations page JS never logs — without reproducing it.

        

        inspect
      

      

        04
        

          
Trusted input on the sites that reject bots

          
All pointer and keyboard events carry isTrusted: true via CDP. Drag-and-drop, canvas and map apps, and file uploads that never expose an <input type=file> in the DOM — including Meta Business Suite and Google Drive — all work.

        

        trusted
      

      

        05
        

          
See inside cross-origin iframes

          
Content scripts run in every frame; refs from nested frames carry an fN prefix and route back automatically. A checkout page whose card fields are a Stripe iframe three levels deep reads as one tree, and clicks land on the right pixel.

        

        iframes
      

      

        06
        

          
Emulation without a second browser

          
Device presets, arbitrary viewports, forced light/dark, user-agent override, and network throttling down to offline. Automation keeps running while the window is minimized, so long jobs get out of your way.

        

        emulate
      

      

        07
        

          
Nine wait conditions instead of sleeps

          
text, no_text, selector, no_selector, ref_gone, url, network_idle, load, time. ref_gone — wait until the spinner disappears — is not expressible as a selector on most SPAs.

        

        wait
      

      

        08
        

          
It says when it cannot do something

          
Obstruction by a cookie banner is reported, naming the covering element. CAPTCHAs are surfaced and never bypassed — that needs a human, and the tool says so instead of looping. Truncation is always reported, because “no matches” and “no matches in the part I read” mean different things.

        

        honest
      

    

  


  
  

    

      Security
      
Privileged by design,
guarded by default

    


    

      

        

          
        

        
Loopback only

        
Binds to 127.0.0.1. Nothing is exposed to your network.

      

      

        

          
        

        
No telemetry

        
No analytics, no outbound calls of any kind. Everything is local.

      

      

        

          
        

        
Blocklist ships populated

        
Identity providers are never automated — a mistake against an SSO flow is expensive and hard to undo.

      

      

        

          
        

        
CAPTCHAs are reported, never solved

        
A blocking challenge must be solved by a human, and the tool says so instead of trying to bypass it.

      

    


    

      
      
Treat an agent with browser access as having your logged-in privileges. Use the site allowlist when running unattended — and turn off the debugger permission in options if you would rather not grant it.

    

  


  
  

    

      Install
      
Running in under a minute

      
Load the extension, point your MCP client at the server, check it. No npm install, no build step.

    


    

      

        
    
          
  1. 
            1
            
    
              
    Load the extension
    
              
    Open chrome://extensions, enable Developer mode, click Load unpacked and select the extension/ folder.
    
            
    
          
    2. 
          
  2. 
            2
            
    
              
    Point your MCP client at the server
    
              
    Pick your client below and copy the snippet. The server is a plain node process — nothing to install.
    
            
    
          
    3. 
          
  3. 
            3
            
    
              
    Check it
    
              
    Run --health. The toolbar badge clears when Chrome is connected, and you are driving a real browser.
    
            
    
          
    4. 
        

      


      

        

          
          
          
        


        

          

            claude mcp add openbrowser
            
          

          
claude mcp add openbrowser -- node /absolute/path/to/openbrowser/mcp-server/src/index.js

        


        

          

            ~/.config/opencode/opencode.json
            
          

          
{
  "mcp": {
    "openbrowser": {
      "type": "local",
      "enabled": true,
      "command": ["node", "/absolute/path/to/openbrowser/mcp-server/src/index.js"]
    }
  }
}

        


        

          

            Standard MCP stdio server
            
          

          
{
  "mcpServers": {
    "openbrowser": {
      "command": "node",
      "args": ["/absolute/path/to/openbrowser/mcp-server/src/index.js"]
    }
  }
}

        


        

          node mcp-server/src/index.js --health
           Node 18+ · Chrome 116+
        

      

    

  


  
  

    

      
      
Open-source, MIT-licensed,
and ready to drive your browser.

      
Star it, fork it, read the architecture notes, or just load it and watch an agent sign into your own inbox.

      

        
          
          View on GitHub