What can you do with this server?

OctoLimb lets any MCP agent drive your real Chrome browser to automate web tasks, read pages, execute JavaScript, and save/replay recipes. * Navigate: go to a URL, search Google, go back, open/close/switch tabs. * Read pages: inspect URL/title and indexed interactive elements (optionally visible body text), get native dropdown options, execute arbitrary JS in the page, and cache content. * Interact: click elements by index, input text, select dropdown options, send special keys/shortcuts. * Scroll: to top/bottom/percent/text, previous/next page. * Wait: pause for a specified number of seconds when explicitly needed. * Recipes: find saved step-by-step recipes for a domain, replay them in one call, batch ad-hoc tool steps, and auto-save successful tasks via done. * Task lifecycle: always call done to signal completion and trigger recipe saving on success.

Which integrations are available for this server?

Enables performing Google searches through the browser via the search_google tool.

How do I use octolimb?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@octolimb go to news.ycombinator.com and read me the top 5 headlines" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

octolimb

by kaleemibnanwar

Overview Schema Source Related Servers Discussions Admin

JavaScript

Local

OctoLimb

MCP for any browser.

Give any MCP agent — Claude Code, Claude Desktop, OpenAI Codex, or your own — a real Chrome browser to drive.

What it is · The Octopus family · Install · Use it with · Tools · Security

What it is

OctoLimb turns a normal Chrome browser into a tool any MCP agent can call. Click, type, scroll, read the page, run JavaScript, and replay saved step-by-step "recipes" — all through your everyday, logged-in browser, not a headless copy.

flowchart LR
    A["Any MCP agent<br/>Claude · Codex · Studio"] -->|stdio or HTTP| B["OctoLimb host<br/>the MCP server"]
    B -->|WebSocket<br/>ws://127.0.0.1:32528| C["Chrome extension<br/>the browser actuator"]
    C -->|CDP + DOM indexer| D["Your real Chrome"]

It ships as two pieces, one package:

Piece	What it does	Where
`octolimb` host	The MCP server. Speaks MCP to your agent and relays tool calls to the browser.	`src/` → builds to `dist/`
Chrome extension	The browser actuator. Performs tool calls in Chrome (CDP input events + nanobrowser's DOM indexer).	`extension/`

Why two processes? A Chrome extension can't listen on a socket or serve stdio — that's a browser security boundary. So the MCP server is a separate host process, and the extension connects out to it.

Related MCP server: OpenCode in Chrome

The Octopus family

OctoLimb is one arm of a bigger octopus, all on the same account:

Repo	What it is	How OctoLimb fits
🧠 Octopus Studio	Local-first AI workspace — research, docs, data, media, automation, MCP, and development	The brain. Studio ships OctoLimb's bridge in-process, so its agent gets a real browser with one toggle. OctoLimb is also a standard MCP server, so it plugs straight into Studio's Connections catalog.
✂️ Octo Cut	Self-driving, non-destructive desktop video editor	The cut arm. OctoLimb browses and gathers clips, images, and audio from the web; Octo Cut assembles them on the timeline.
🐙 OctoLimb	MCP for any browser	The browser arm — drives any website for any agent.

The workflow: Octopus Studio is the hub. Its agent calls OctoLimb to go out and do things in the browser — fetch a stock clip, pull a reference, fill a form, post an update — and feeds the results back into the project, or into Octo Cut for editing. OctoLimb is how the octopus reaches beyond your machine into the open web.

Install

Load the extension

Open chrome://extensions.
Enable Developer mode (top-right toggle).
Click Load unpacked and select the extension/ folder.

The extension dials out to ws://127.0.0.1:32528 and reconnects automatically whenever the host comes up.

Install the host

npm install -g octolimb      # from npm, or:
# git clone https://github.com/kaleemibnanwar/octolimb.git && cd octolimb && npm install && npm run build && npm link

Confirm it's on your path:

octolimb --help

Use it with

The host runs as a stdio server (default — the most universal) or a Streamable HTTP server. Both always start the WebSocket relay on :32528 for the extension.

Octopus Studio

Octopus Studio already ships an in-process OctoLimb bridge — no standalone host needed. Load the extension, then enable Settings → "Enable OctoLimb MCP Bridge". Studio's agent can then drive a browser for tasks like "post this on Reddit" or "pull the latest pricing from that page."

Don't run the standalone host at the same time — Studio's bridge and this host both bind :32527/:32528. Pick one. (To run both, start the host with --http-port 32529 --ws-port 32530.)

Claude Code

claude mcp add octolimb -- octolimb

Or via .mcp.json:

{
  "mcpServers": {
    "octolimb": { "command": "octolimb", "args": [] }
  }
}

Claude Desktop

Settings → Developer → Edit Config, then add to claude_desktop_config.json:

{
  "mcpServers": {
    "octolimb": { "command": "octolimb", "args": [] }
  }
}

Restart Claude Desktop. (HTTP is also possible — see below.)

Codex

Add to ~/.codex/config.toml:

[mcp_servers.octolimb]
command = "octolimb"
args = []

Any other MCP client

stdio (most common): configure the client to spawn octolimb as a command.
Streamable HTTP: run octolimb --http, then point the client at http://127.0.0.1:32527/mcp.

octolimb --http                                   # HTTP MCP on :32527 + WS relay on :32528
octolimb --http-port 32529 --ws-port 32530        # override ports

Tools

The host exposes 24 tools:

Category	Tools
🧭 Navigation	`go_to_url`, `go_back`, `open_tab`, `close_tab`, `switch_tab`, `search_google`
📖 Reading	`read_page` (URL/title + indexed elements), `execute_js`, `get_dropdown_options`
🖱️ Interaction	`click_element`, `input_text`, `select_dropdown_option`, `send_keys`, `wait`
📜 Scrolling	`scroll_to_percent`, `scroll_to_top`, `scroll_to_bottom`, `previous_page`, `next_page`, `scroll_to_text`
🔁 Recipes	`find_recipe`, `run_recipe`, `done` (auto-saves a task on success), `cache_content`

See extension/README.md for how the extension implements these (nanobrowser's DOM indexer + CDP input dispatch).

Saved recipes

done, find_recipe, and run_recipe give the agent a lightweight memory: a successfully completed task is saved and can be replayed later on the same domain in one run_recipe call instead of step-by-step. Recipes live as JSON at ~/.octolimb/recipes.json (override the directory with OCTOLIMB_HOME).

Security

The host binds to 127.0.0.1 only — never a network interface.
The WebSocket relay accepts only chrome-extension:// origins, so other local processes can't impersonate the browser.
Driving Chrome shows its unavoidable "OctoLimb Bridge is debugging this browser" banner on attached tabs.
execute_js runs arbitrary JavaScript in the page — grant the extension only to tasks you actually want automated.

License

Apache-2.0 — see LICENSE. The DOM-indexing script (extension/buildDomTree.js) is copied from nanobrowser and carries its own Apache-2.0 license files in extension/.

Available Tools

24 tools

cache_contentC

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Cache what you have found so far from the current page for future use

Inputs: intent, content.

click_elementB

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Click element by index

Inputs: index (required), xpath, intent.

close_tabB

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Close tab by tab id

Inputs: tab_id (required), intent.

doneA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Complete task. Always call this once you're finished with a browser task, whether it succeeded or not — besides signaling completion, on success this automatically saves everything you did since the last find_recipe/done as a recipe (using text as its instruction), so a future task on this site can replay it via find_recipe instead of redoing every step. This is the only thing that triggers auto-saving — individual actions (go_to_url, click_element, etc.) are silently recorded as you go, but nothing is persisted until done() is called with success: true.

Inputs: text (required), success (required).

execute_jsA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Execute arbitrary JavaScript in this task's tab (page context) and return the result.

Inputs: code (required).

find_recipeA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] List every previously saved step-by-step trajectory for this domain, before doing the task manually. Returns each saved recipe's own instruction text plus its fingerprint and success/failure counts — no steps yet. Read the instructions like retrieved documents and judge for yourself whether any of them is the same task you're about to do, even if worded differently ('post a tweet' vs 'tweet something'); ignore recipes that don't actually match. If one fits, pass its fingerprint straight into run_recipe to replay the whole task in one call instead of one tool call per step. Always try this first for any task that sounds like something you (or a prior session) may have already done on this site.

Inputs: domain (required).

get_dropdown_optionsB

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Get all options from a native dropdown

Inputs: index (required), intent.

go_backA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Go back to the previous page

Inputs: intent.

go_to_urlA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Navigate to URL. Opens a new tab for this task if none is active yet, otherwise navigates the tab already in use for this task — never the user's own currently-focused tab, and every later action (click_element, read_page, etc.) keeps targeting that same tab even if the user clicks into a different one meanwhile.

Inputs: url (required), intent.

input_textA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Input text into an interactive input element

Inputs: text (required), index (required), xpath, intent.

next_pageA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Scroll the document in the window or an element to the next page. If no index is specified, scroll the whole document.

Inputs: index, intent.

open_tabA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Open URL in a new tab, and use it as this task's tab from now on.

Inputs: url (required), intent.

previous_pageA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Scroll the document in the window or an element to the previous page. If no index is specified, scroll the whole document.

Inputs: index, intent.

read_pageA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Read the current page in this task's tab: URL, title, and an indexed list of interactive elements. Call this before click_element, input_text, or the dropdown tools to get valid indices. Body text is omitted by default — pass include_text when you actually need to read page content, not just interact with it.

Inputs: include_text, max_text_length, viewport_expansion.

run_recipeA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Execute a sequence of OctoLimb tool steps in one call, without round-tripping to you between each one — use this to batch obvious action chains (e.g. go_to_url, then click_element, then input_text) or to replay steps returned by find_recipe. Runs steps exactly as given, in order, via the real browser — nothing is added or skipped, so include every step you'd need if doing this by hand one call at a time (e.g. a read_page before an index-based step on a page you haven't indexed yet in this session). Stops at the first step that errors, returning every result so far plus which step failed — pick up manually from there. Pass fingerprint (from find_recipe) to replay and auto-update its success/failure count instead of passing steps directly. Pass save_as alongside steps to save this task once it fully succeeds — this saves every tool call made in the session so far (including ones made outside this run_recipe call, e.g. an earlier read_page), not just the steps in this call, so replay later needs nothing extra.

Inputs: steps, save_as, fingerprint.

scroll_to_bottomB

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Scroll the document in the window or an element to the bottom

Inputs: index, intent.

scroll_to_percentA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Scrolls to a particular vertical percentage of the document or an element. If no index of element is specified, scroll the whole document.

Inputs: yPercent (required), index, intent.

scroll_to_textA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] If you dont find something which you want to interact with in current viewport, try to scroll to it

Inputs: text (required), nth, intent.

scroll_to_topB

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Scroll the document in the window or an element to the top

Inputs: index, intent.

search_googleA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Search the query in Google. Opens a new tab for this task if none is active yet, otherwise reuses the tab already in use for this task — never the user's own currently-focused tab. The query should be a search query like humans search in Google, concrete and not vague or super long. More the single most important items.

Inputs: query (required), intent.

select_dropdown_optionA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Select dropdown option for interactive element index by the text of the option you want to select

Inputs: text (required), index (required), intent.

send_keysB

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Send strings of special keys like Backspace, Insert, PageDown, Delete, Enter. Shortcuts such as Control+o, Control+Shift+T are supported as well. This gets used in keyboard press. Be aware of different operating systems and their shortcuts

Inputs: keys (required), intent.

switch_tabA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Switch to tab by tab id, and make it the tab this task uses from now on (e.g. after a link opened a new tab).

Inputs: tab_id (required), intent.

waitA

[Real Chrome browser via the OctoLimb extension — drive the user's browser; use only when the task requires acting on a real website.] Wait for x seconds default 3, do NOT use this action unless user asks to wait explicitly

Inputs: intent, seconds.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.5/5.0

Scored 2026-09-30 03:10 across 24 tools

Disambiguation4/5

Most tools target clearly distinct browser actions, and the descriptions explicitly distinguish tab-scoped navigation from browser history (go_back) and scrolling. There is some potential overlap between scroll variants and pagination tools, and execute_js could be seen as a catch-all alternative, but the intended boundaries are mostly clear.

Naming Consistency4/5

Nearly all names use readable snake_case, and action tools generally follow verb_noun or verb patterns. Minor deviations include one-word controls like done and wait, and noun-only names like previous_page and next_page, but the set remains predictable overall.

Tool Count3/5

At 24 tools, the set is on the heavy side for a browser automation server and includes several granular scroll and tab primitives that could be consolidated. However, each tool does correspond to a real browser operation, so the count is not entirely unjustified.

Completeness4/5

The surface covers core browser workflows: navigation, inspection, clicking, text input, scrolling, tabs, dropdowns, JavaScript execution, and recipe replay. Some gaps remain, such as explicit hover, drag-and-drop, file upload, screenshots, or forward navigation, but these are relatively minor for many tasks.

Maintenance

ActivitySlowing

ResponsivenessOutdated data

Resources

Related MCP Connectors

browser-mcp
io.github.Shreyas-Profile
Hosted real Google Chrome MCP with per-user persistent state. Navigate, click, type, screenshot.
Browser Automation Web Scraping
2
https://browser.regiq.in/api/mcp
Aginx BrowserA
net.aginx
Stealth web browser for agents: search, fetch, click, download and type in persistent MCP sessions.
Browser Automation Agent Orchestration
156
https://browser.aginx.net/mcp
BrowserHere
app.1ts.browserhere
Control a real browser from AI agents: navigate, click, type, screenshot, read the page.
Browser Automation Agent Orchestration
1
https://browserhere.1ts.app/mcp
Browserless
io.browserless
Official Browserless MCP server: browser automation, scraping, screenshots and PDFs for AI agents.
Browser Automation Web Scraping Agent Orchestration
119
https://mcp.browserless.io/mcp

Related MCP Servers

browser-mcp
Shreyas-Profile
A
license
Not graded
quality
D
maintenance
Hosted Chrome as an MCP skill. Enables any MCP-compatible agent to drive a real Chromium browser for tasks like navigation, clicking, typing, and taking screenshots.
Updated 4 months ago (2026-07-22 15:55 UTC)
17 npm
MIT
OpenCode in Chrome
Browser Automation Agent Orchestration
Mukller
A
license
Not graded
quality
B
maintenance
Enables local opencode agents to control a live Chrome browser via MCP tools, including tab management, JavaScript execution, clicking, form filling, page reading, screenshots, and console log retrieval.
Updated 2 months ago (2026-09-10 23:00 UTC)
2
MIT
WebOperator MCP Server
Browser Automation Autonomous Agents Agent Orchestration
KazKozDev
A
license
Not graded
quality
B
maintenance
Enables MCP clients to drive a live Chrome or Brave browser over stdio, with tools for navigation, clicking, typing, screenshots, and executing automation goals.
Updated 20 days ago (2026-10-26 08:18 UTC)
4
MIT
Pagewright (browser-mcp)
Browser Automation Web Scraping Developer Tools
zamansheikh
A
license
Not graded
quality
B
maintenance
Enables AI agents to see and control the user's real Chrome/Brave/Edge profile over MCP, so they can read pages, click, type, take screenshots, audit layouts, debug CSS, and scrape paginated or infinite-scroll data. Because it drives the normal browser via the DevTools protocol with real input events, it works on modern JavaScript apps and on sites where the user is logged in.
Updated 11 days ago (2026-11-03 21:35 UTC)
17 npm
1
MIT

OctoLimb

MCP for any browser.

What it is

The Octopus family

Install

Load the extension

Install the host

Use it with

Octopus Studio

Claude Code

Claude Desktop

Codex

Any other MCP client

Tools

Saved recipes

Security

License

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

browser-mcp

OpenCode in Chrome

WebOperator MCP Server

Pagewright (browser-mcp)