Skip to content

Browser Control: Let Claw Browse and Operate the Web for You ​

The scheduled tasks from the previous lesson solved "when to do it"; this lesson solves "with what to do it". OpenClaw splits Claw's web capabilities into two layers: the lightweight trio (web_search / x_search / web_fetch, HTTP requests, no browser opened) and OpenClaw browser control (browser tools, a real Chromium).

The browser runs by default in a managed profile called openclaw—its own data directory, fully isolated from your everyday browser. Claw opens tabs, reads pages, clicks, types, and takes screenshots inside it, never touching your login state or bookmarks; when login state is truly needed, bring it in using one of the three ways from Step 5. All examples are based on OpenClaw v2026.10.9.

What You'll Be Able to Do After This Lesson ​

  • Distinguish the two layers of web capability: use the web_search / x_search / web_fetch lightweight trio for research, and browser tools for operating web pages
  • Configure a search provider so Claw's web_search works out of the box (DuckDuckGo requires no API Key)
  • Launch an isolated OpenClaw browser and let Claw open tabs, click, type, take screenshots, and download
  • Bring login state along (choose one of three): log in manually to the managed profile, reuse an already-logged-in Chrome with the user profile, or unattended via a Chrome extension
  • Avoid two classic pitfalls: the coding tool configuration doesn't include browser, and the login window is invisible in headless mode

Your Current Pain Points ​

  • Ask AI "what's the latest version of some tool"—it has no internet, so the answer is either outdated or made up
  • Logging into the same admin panel every day, clicking the same buttons, downloading the same report, until you're numb from the repetition
  • Wanting AI to operate a browser, but afraid it will mess up your own login state, tabs, and bookmarks

When to Use This Technique ​

When you need to:

  • Look up the latest information: search web pages, fetch the content of a specific URL, look up X (formerly Twitter) posts
  • Take action on web pages: click buttons, fill forms, download files, take screenshots as evidence
  • Work with login state: admin reports, internal systems, pages visible only to you

And you don't want to:

  • Write Playwright / Selenium scripts yourself, set up environments, and debug selectors
  • Expose your everyday browser to automation and have your login state and tabs thrown into chaos
  • Manually repeat the exact same click flow every day

🎒 Preparation Before You Start ​

  • Completed the Efficient Workflows Stage Overview: the Gateway is running and at least one model is connected
  • A Chromium-based browser on the machine running the Gateway (any of Chrome / Brave / Edge / Chromium)—if you only use the trio for research, this isn't required
  • Want web_search to work out of the box: have an API Key for a search provider ready, or just use the key-free DuckDuckGo
  • Want to reuse an already-logged-in Chrome: local Chrome version 144+
  • A cup of water ☕—the commands in this lesson are all short; just copy and run

Core Idea ​

First distinguish the two layers of capability, then remember the three kinds of profiles.

First, distinguish: two layers of web capability.

LayerToolsWhat it doesCharacteristics
Lightweight trioweb_search / x_search / web_fetchSearch web pages, look up X posts, fetch URL contentHTTP requests, no browser opened, fast
OpenClaw Browserbrowser toolsOpen tabs, click, type, take screenshots, downloadA real Chromium, can handle JS-heavy, interactive sites

web_search goes through your configured search provider (results cached per query for 15 minutes); x_search looks up X posts via xAI; web_fetch always fetches locally and lightweight. Only when a site is JS-heavy, requires login, or needs button clicks does the browser come into play.

Then remember: three kinds of browser profiles. This is the most core selection table of this lesson:

ProfileWhat it isWhen to useUnattended
openclaw (default)A managed, isolated browser from OpenClaw with its own data directoryThe default choice; operate web pages in a clean environment✅
userConnects to your real, logged-in Chrome via Chrome DevTools MCPRequires a logged-in session, and you're at the computer to approve the connection❌ The first time you must approve "Allow remote debugging?"
chromeDrives your real, logged-in Chrome via a Chrome extensionRequires a logged-in session, but you don't have to be at the computer (remote control from your phone)✅

Isolation guarantee: the openclaw profile never touches your personal browser profile—think of it as "another browser dedicated to Claw." Only user / chrome enters your already-logged-in session, with greater capabilities and higher risk—choose as needed.

Follow Along ​

Why: among the trio, web_search is the most frequently used, but it needs a search provider behind it; when none is configured, OpenClaw simply removes web_search from the agent's tool list.

How (Control UI, recommended): open Settings → Search, pick a search provider, fill in the credentials, and click Test search for a trial run.

How (CLI):

bash
openclaw configure --section web

Key-free option: DuckDuckGo doesn't require an API key. Note that key-free providers are not selected automatically—either explicitly choose one here, or set tools.web.search.provider. API providers can also be set directly via environment variables to skip this step, e.g. BRAVE_API_KEY.

💡 Users in China, look here

There are two domestic options among the search providers: Kimi (Moonshot, using KIMI_API_KEY / MOONSHOT_API_KEY) and MiniMax Search (using MINIMAX_CODE_PLAN_KEY / MINIMAX_CODING_API_KEY / MINIMAX_OAUTH_TOKEN)—just fill in the corresponding key in the configuration.

You should see: Test search returns results (or a success message, possibly with a delay); afterwards, tell Claw "search for the latest version of OpenClaw" and it can give an answer with source URLs.

  • Quick check: have Claw search for any word; the answer includes source links

Step 2: Try the trio—search, fetch page content, look up X posts ​

Why: first get a feel for how far you can go "without opening a browser"—many tasks end at this layer, with no need for the heavier browser.

How: say three things to Claw in the chat:

  • "Search for the big AI news from the past week" → web_search (supports time filters like week / month)
  • "Fetch the content of https://example.com and give me a three-sentence summary" → web_fetch (always runs locally)
  • "What recipe posts has nytfood made recently on X" → x_search

You should see: Claw returns structured results—titles, URLs, summaries, or a synthesized answer with citations.

⚠️ x_search is billed by xAI

x_search runs on xAI's servers: 5 dollars per 1000 calls, plus the model's input and output tokens. By default it is only exposed when the current model provider is xAI; to use it with other models, you must explicitly set plugins.entries.xai.config.xSearch.enabled to true.

Step 3: Launch the OpenClaw browser (isolated managed mode) ​

Why: the default openclaw profile is that "dedicated browser"—its own data directory, headless by default, completely independent of your everyday browser. Launch it manually once first to confirm it runs on your machine.

How:

bash
openclaw browser --browser-profile openclaw doctor
openclaw browser --browser-profile openclaw start
openclaw browser --browser-profile openclaw open https://example.com
openclaw browser --browser-profile openclaw snapshot

You should see: doctor all green; open opened a tab; snapshot returns structured references (refs) for the page—element numbers like e12—which are the "coordinates" for clicking and typing in the next step.

  • Quick check: openclaw browser --browser-profile openclaw tabs can list the tab that was just opened

Step 4: Have Claw operate web pages—click, type, screenshot ​

Why: the real value of the browser tools is "doing it for you." The agent takes snapshots, finds elements, performs actions, and rescues itself when things go wrong—you just describe the goal.

How: say this to Claw in the chat:

Open example.com, type openclaw into the search box, click the search button, and send me a screenshot of the results page.

Internally, Claw runs a "snapshot → action → snapshot again" loop (the browser plugin ships with the browser-automation skill): actions include click / type / hover / drag / select, plus taking screenshots, exporting PDFs, and waiting for downloads to finish. When it hits walls it can't handle—logins, 2FA, CAPTCHAs—it reports "manual operation needed" instead of guessing blindly.

Equivalent CLI commands (you can drive this same browser from your terminal):

bash
openclaw browser click <ref>
openclaw browser type <ref> "hello"
openclaw browser screenshot

You should see: Claw completes the actions and describes the result. Note that screenshots are private tool results—the agent can see them itself, but they aren't automatically attached to chat replies; it only sends them if you explicitly ask. Downloads triggered by clicks are saved to the managed downloads directory (default /tmp/openclaw/downloads).

Step 5: Give the browser a logged-in session (three ways) ​

Why: the isolated profile is "clean"—it contains none of your logins. To operate pages that require being logged in, pick one of three options based on your scenario.

Option A (recommended): manually log in to the managed profile once ​

Manual login is the official recommendation: automatic logins tend to trigger websites' anti-bot defenses, and in severe cases can get your account locked outright. Temporarily switch the browser to headed mode, log in by hand once, and the session stays in this profile:

bash
openclaw browser stop
openclaw config set browser.headless false
openclaw browser start
openclaw browser open https://x.com

Complete the login in the window that pops up; afterwards you can switch back to headless (openclaw config set browser.headless true). Whatever you do, don't run reset-profile—it wipes the login data you just saved.

Option B: user profile reuses your logged-in Chrome (you're at the computer) ​

  1. Upgrade Chrome to 144+, go to chrome://inspect/#remote-debugging in the address bar, and enable remote debugging
  2. Connect and check the status:
bash
openclaw browser --browser-profile user start
openclaw browser --browser-profile user status
openclaw browser --browser-profile user tabs
  1. The first time you connect, Chrome shows an "Allow remote debugging?" authorization prompt—which is why you need to be sitting at the computer.

You should see: status reports driver: existing-session, transport: chrome-mcp, running: true; tabs lists the tabs already open in your Chrome—Claw works directly in your real session.

Option C: chrome extension (you're not at the computer) ​

Run openclaw browser extension install on the machine where Chrome lives, and follow the prompts to enable the OpenClaw extension in Chrome; once installed, Claw drives your real Chrome's tabs through the extension—no debug port, no authorization popup—so even when you're out, you can remotely control the logged-in browser on your home computer from your phone (Telegram / WhatsApp).

💡 macOS users: you can import cookies only

openclaw browser import-profile --browser chrome --system Default --into imported --domains github.com can decrypt the system Chrome's cookies and inject them into an isolated managed profile (the first time requires Keychain / Touch ID approval). Only cookies are copied; localStorage and IndexedDB stay where they are; some Google sessions use device-bound credentials (DBSC), so you may still need to log in again after importing.

  • Quick check: pick a page that requires login, and have Claw read the logged-in content using your chosen method

Checkpoint ✅ ​

  • Tell Claw "search for the latest version of OpenClaw" and the answer includes source URLs
  • openclaw browser --browser-profile openclaw doctor all green, and tabs can list tabs
  • Claw can open pages, click, type, and take screenshots in the isolated browser
  • You can explain the division of labor among the three profiles: openclaw isolated managed, user reusing Chrome while you're at the computer, chrome extension for unattended use
  • Know that x_search is billed via xAI (per 1000 calls at 5 USD each + tokens), so you won't be startled by the bill at month's end

Pitfall Warnings ​

❌ openclaw browser command not found, or the agent says the browser tool is unavailable ​

Cause: the config contains a plugins.allow list without browser listed, and there is no root-level browser config block either—the browser plugin is blocked by policy, and a simple restart won't fix it.

Correct approach (choose one of two):

json5
// 方式一:把 browser 加进 allow 列表
{ plugins: { allow: ["telegram", "browser"] } }

// 方式二:加任意 browser.* 配置键(比如 browser.enabled = true),
// 也能在严格的 allow 列表下激活内置浏览器插件

❌ You used tools.profile: "coding", and the browser tool simply isn't in ​

Cause: the coding tool configuration only includes web_search and web_fetch, and does not include the full browser tool.

Correct approach:

json5
{ tools: { profile: "coding", alsoAllow: ["browser"] } }

When allowing the browser for subagents, note: setting only tools.subagents.tools.allow: ["browser"] is useless—the subagent policy applies after profile filtering, so you must allow it at the profile level.

❌ user profile can't connect: tabs throws errors, status isn't running ​

Check each item on the list:

  • Is the Chrome version 144+
  • Is remote debugging enabled in chrome://inspect/#remote-debugging
  • Did you click approve on the connection authorization prompt that Chrome popped up

If everything is correct and it still doesn't work, run openclaw doctor for diagnostics. Note that doctor cannot open remote debugging on the browser side for you—this step must be done manually.

❌ Login appears "stuck" in headless mode ​

Cause: locally hosted profiles are headless by default (headless: true), so the login window is simply invisible; in headless mode, Chrome's passkey dialog is also treated by OpenClaw as "cancelled" (this is to keep the page usable, not a bug).

Correct approach: always switch to headed mode for login (the set of commands in Approach A), then switch back after logging in. Sites that log in with passkeys / security keys must use a headed profile.

Advanced Tips (Optional) ​

Combo move: scheduling + web access. Combine the cron loop from the previous lesson with this lesson's trio and browser, and you get two practical scenarios: daily morning brief and web monitoring—just copy them and they'll run.

The Browser panel in Control UI. In the web console you can see in real time which tab Claw is currently operating (following the active session); click a preview card to switch to that browser and that tab—whatever Claw is doing on the web is visible at a glance.

Text-only models can also "see" screenshots. When the main model has no vision capability, browser screenshots are automatically sent through an image-understanding model and converted into text descriptions (configured via tools.media.models); no separate model needs to be configured for the browser.

Beyond the browser: Computer Use. On paired Macs and explicitly enabled Windows machines, Claw can also operate the entire computer interface (new in OpenClaw 2.0), with the browser being just one part of it.

Multiple profiles and remote browsers. openclaw browser create-profile --name work creates a second isolated browser (separate work/personal); when the browser is on another machine, configure remote CDP (cdpUrl) or use a node host proxy.

Lesson Summary ​

✅ Two layers of web access: the lightweight trio of web_search / x_search / web_fetch handles "looking things up," while the browser tool handles "taking action."

✅ The OpenClaw browser defaults to an isolated hosted profile: its own data directory, headless by default, never touching your everyday browser.

✅ Three profile types with distinct roles: openclaw (default, unattended), user (Chrome DevTools MCP, requires a person at the computer to approve), chrome (extension, unattended reuse of login state).

✅ Three paths for login state: manually logging into a hosted profile (officially recommended), user to reuse an already-logged-in Chrome, or on macOS exporting only cookies into the isolated profile.

✅ Two big pitfalls: if plugins.allow doesn't include browser, the CLI and tools disappear together; the coding profile needs alsoAllow: ["browser"].

Key configuration fieldRecommended valueDescription
browser.defaultProfile"openclaw"Uses the isolated browser by default
browser.headlesstrue (temporarily false when logging in)Locally hosted profiles are headless by default
tools.web.search.provider"duckduckgo" (no key required) / "brave"Search provider; key-free providers are not auto-selected
plugins.allowmust include "browser"When an allow list exists, it must list everything
tools.alsoAllow["browser"]coding profile allows the browser for the agent

Next Lesson Preview ​

The browser gives Claw a pair of hands for the web; the next lesson MCP Integration: Giving Claw an External Toolbox teaches you to swap those hands for arbitrary tools—the agent "borrows" tools from other programs.

You will learn:

  • What MCP is: Model Context Protocol, the standard protocol for agents to borrow tools from external programs
  • Three integration surfaces: Control UI's Settings → MCP, the openclaw mcp command, and configuration files
  • The reverse operation: openclaw mcp serve exposes OpenClaw to other MCP clients
  • MCP tools go through the same permission controls—integration does not mean granting authority

Related Tutorials ​

gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.