Agenten stärken
Der eigene Befehl des Herausgebers. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
npx -y [email protected]Claude Code hat keinen Installationslink für einen lokalen Befehl. Kopieren Sie den Befehl unten und führen Sie ihn in einem Terminal aus.
claude mcp add app.crawlio-crawlio-browser -- npx -y crawlio-browser@1.11.0In einem Terminal ausführen.
{ "mcpServers": { "app.crawlio-crawlio-browser": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenMCP server that gives AI full control of a live Chrome browser via CDP. 150 tools with framework-aware intelligence, typed evidence infrastructure, tracking pixel analysis, technographic fingerprinting, SEO auditing, and confidence-tracked findings — captures what static crawlers can't see.
Use Crawlio Browser when your AI needs to interact with a real browser — SPAs, authenticated pages, dynamic content, JS-rendered frameworks. Unlike headless browser tools, Crawlio Browser connects to your actual Chrome via a lightweight extension, giving the AI access to your logged-in sessions, cookies, and full browser state.
Crawlio Browser vs headless browser tools: Headless tools launch a separate browser process. Crawlio Browser connects to your existing Chrome — no separate browser, no login flows, full access to your tabs and sessions.
[!WARNING] This is the trade-off, stated plainly: connecting your own Chrome is the feature, and it means an AI agent can act as you on every site you are logged into. It attaches Chrome's debugger to the tab you connect, so it can read cookies, storage, and page content for that session.
Review what you connect it to. Prefer a dedicated Chrome profile for agent work. Nothing is captured until you connect a tab, and you can see the exact tool surface before configuring anything by running
npx crawlio-browser tools. Sites can opt out with<meta name="crawlio-agent" content="disable">, which the extension honors.
npx crawlio-browser init
That's it. Auto-detects and configures 14 MCP clients: Claude Code, Cursor, VS Code, Codex, Gemini CLI, Claude Desktop, ChatGPT Desktop, Windsurf, Cline, Zed, Goose, OpenCode, MCPorter, and Cline CLI.
npx crawlio-browser init # Default: code mode, stdio transport
npx crawlio-browser init --full # Full mode (every tool exposed individually)
npx crawlio-browser init --portal # Portal mode (persistent HTTP server)
npx crawlio-browser init --cloudflare # Add Cloudflare MCP (89 tools, no wrangler)
npx crawlio-browser init --dry-run # Show what would happen
npx crawlio-browser init --yes # Skip prompts (CI / scripted installs)
npx crawlio-browser init -a claude # Target specific MCP client
The package is also an Agent Plugins v1 plugin, so a conformant client
can load it directly instead of running the wizard — plugin.json at the root, the eleven skills
under skills/, and the MCP server declared in mcp.json.
The product-facing crawlio-* workflows are folded into the eleven shipped skills. The similarly
named definitions in agents/ remain repo-local development fixtures: they import src/evidence/*
and loops/*, neither of which is part of the npm runtime. They are excluded from package.json
instead of advertising a second, non-executable product surface.
Point the client at the installed package:
node_modules/crawlio-browser # after `npm install crawlio-browser`
mcp.json resolves the server through ${PLUGIN_ROOT}/dist/mcp-server/index.js, which is why the
plugin has to be an installed package rather than an unpacked tarball — the server imports its
dependencies at runtime, so a bare extract starts and then dies without answering.
npx crawlio-browser tools # What code mode exposes (the default)
npx crawlio-browser tools --full # Every tool, individually
npx crawlio-browser tools --json # Machine-readable, for diffing across versions
npx crawlio-browser doctor # Bridge, portal, native host, client configs
npx crawlio-browser --help # All commands and options
npx crawlio-browser --version # Version only
Both are read-only and run without a browser, an extension, or a network connection — you can see the whole surface before you configure any client. The numbers come from the same builders the server registers, so they cannot disagree with what your client receives.
Portal mode is recommended for Claude Code — the server persists across context compaction and session restarts. On macOS, --portal installs a launchd agent for auto-start on login.
Claude Desktop — add to claude_desktop_config.json:
{ "mcpServers": { "crawlio-browser": { "command": "npx", "args": ["-y", "crawlio-browser"] } } }
Claude Code (Portal Mode) — start npx crawlio-browser --portal, then add to .mcp.json:
{ "mcpServers": { "crawlio-browser": { "type": "http", "url": "http://127.0.0.1:3001/mcp" } } }
Claude Code (stdio):
claude mcp add crawlio-browser -- npx -y crawlio-browser
Cursor — add to .cursor/mcp.json:
{ "mcpServers": { "crawlio-browser": { "command": "npx", "args": ["-y", "crawlio-browser"] } } }
Windsurf — add to Windsurf Settings > MCP:
{ "mcpServers": { "crawlio-browser": { "command": "npx", "args": ["-y", "crawlio-browser"] } } }
Cline (VS Code) — add to settings.json:
{ "cline.mcpServers": { "crawlio-browser": { "command": "npx", "args": ["-y", "crawlio-browser"] } } }
ChatGPT Desktop — Settings > Integrations > MCP:
URL: http://127.0.0.1:3001/mcp | Type: Streamable HTTP
AI Client (stdio/http) --> MCP Server (Node.js) --> Chrome Extension (MV3)
crawlio-browser WebSocket -> CDP
The MCP server communicates with the Chrome extension via WebSocket. The extension controls the browser through Chrome DevTools Protocol (CDP).
Every execute call probes the browser for framework signatures and injects a shape-shifting smart object with framework-native accessors. React state, Vue reactivity, Next.js routing, Shopify cart data — 17 framework namespaces across 4 tiers, detected at runtime and rebuilt on every navigation. The AI doesn't query a generic DOM; it queries the framework's own data structures.
Method Mode adds higher-order methods and a typed evidence system on top of Code Mode. smart.extractPage() runs 7 parallel operations in a single call — page capture, performance metrics, security state, font detection, meta extraction, accessibility audit, and mobile-readiness check. Failed operations produce typed CoverageGap records instead of silent nulls. Findings created with smart.finding() get their confidence automatically adjusted when supporting data is missing. The result: structured, auditable research output with gap tracking and confidence propagation.
Record browser interactions as structured data, then compile them into reusable SKILL.md automations. 12 interaction tools are automatically intercepted during recording — clicks, typing, navigation, scrolling — each capturing args, result, timing, and page URL. One compileRecording() call converts the session into a deterministic automation script.
Capture human-guided browser demonstrations as replayable robot-training bundles. The default-mode
observe lifecycle starts an event-driven recorder inside the extension; collection keeps running
if the MCP process disconnects or restarts. On reconnection, training_stop exports the retained
run and materializes the complete 13-file RecordingBundle for replay and API synthesis. Full mode
keeps the existing robot_training_* names as compatibility aliases.
Page monitoring is resident for the same reason: an extension-owned background tab and Chrome alarm collect bounded ARIA snapshots while no MCP server is present. Training and monitor history share a 25 MiB local budget, with 20 completed training runs, 50 monitor jobs, 200 snapshots total, and 50 snapshots per monitor as count caps. Old completed data is evicted first; active work is never silently evicted. Work starts only through explicit MCP lifecycle actions; the same actions report status, stop collection, clear monitor snapshots, and—with an exact id plus explicit confirmation—delete a stopped training/recording record from Chrome while preserving its materialized files. The extension popup remains a connection and browser-access status surface. Storage values are keys-only unless the caller explicitly opts in. Monitor snapshots intentionally retain compact ARIA page text locally; starting a monitor should therefore be treated as consent to retain the visible content of that URL until it is cleared.
Every mutative action (click, type, navigate, select_option) runs actionability checks before acting — polling visibility, dimensions, enabled state, and overlay detection. After the action, a progressive backoff settle delay ([0, 20, 100, 100, 500]ms) waits for DOM mutations to quiesce. The AI doesn't need manual sleep() calls between actions.
Any command that acts on a page takes an optional tabId from list_tabs. Omit it and the command runs on the connected tab, exactly as before; supply one and it runs on that tab instead, with the whole command surface available on each. Commands overlap, so two tabs can be driven at the same time:
const [checkout, search] = await Promise.all([
bridge.send({ type: "browser_snapshot", tabId: 42 }),
bridge.send({ type: "browser_snapshot", tabId: 57 }),
]);
Targeting a tab never changes which tab connect_tab points at, so an agent working several tabs cannot reassign the one a human is watching. Frame selection, coverage sessions, and framework detection are per tab. Network capture is the exception — it records one tab at a time and says which tab holds it rather than interleaving two.
An extension instance is confined to its own Chrome profile and cannot see any other, so with Crawlio enabled in more than one, commands land in whichever profile connected first. list_profiles shows the profiles that have connected and which is being driven; switch_profile moves the connection to another. One profile is driven at a time — the released extension reconnects in the background, so switching back is immediate.
Profiles identify themselves with a UUID minted into their own extension storage. It distinguishes a profile without describing it: no account, no email, no path, and no additional permission.
Selecting a profile keeps cooperating extensions out of each other's way — it is not a security boundary, since the id is asserted by the extension rather than proved. The bridge's existing protections are unchanged: one extension at a time, and each must prove the server holds the real bridge token before anything executes.
A layered execution architecture where each layer absorbs a category of complexity that would otherwise fall on the model. The model sees four primary tools and a clean SDK. Everything beneath that surface is the runtime absorbing reality.
The layer worth understanding is the one that assembles itself. Detection runs against the live page on first use, and the smart object is built to match what that page turned out to be — smart.react.* exists only where React does. Nothing about the target is known at startup, so the surface is composed per tab rather than declared up front.
┌───────────────────────────────────┐
│ AI Model (LLM) │
│ Writes code, reads errors, loops │
└───────────────┬───────────────────┘
│ search, execute, observe, connect_tab (+ 3 job tools)
▼
┌─────────────────────────────────────────────────────────────────┐
│ Crawlio Browser runtime │
│ │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ METHOD MODE │ │
│ │ Behavioral protocol + higher-order methods │ │
│ │ scrollCapture · waitForIdle · extractPage · comparePages │ │
│ │ detectTables · extractTable · waitForNetworkIdle · │ │
│ │ extractData │ │
│ │ │ │
│ │ ↳ Absorbs: behavioral variance, ad-hoc composition, │ │
│ │ inconsistent output shapes, data extraction patterns │ │
│ ├────────────────────────────────────────────────────────────┤ │
│ │ POLYMORPHIC CONTEXT │ │
│ │ 17 framework namespaces, injected Just-In-Time │ │
│ │ react · vue · angular · nextjs · shopify · ... │ │
│ │ │ │
│ │ ↳ Absorbs: framework opacity, minified code, │ │
│ │ devtools hook complexity │ │
│ ├────────────────────────────────────────────────────────────┤ │
│ │ ACTIONABILITY ENGINE │ │
│ │ 7 core smart methods with built-in resilience │ │
│ │ click · type · navigate · waitFor · evaluate · │ │
│ │ snapshot · rebuild │ │
│ │ │ │
│ │ ↳ Absorbs: DOM timing, hydration delays, CSS animations, │ │
│ │ disabled states, overlapping elements │ │
│ ├────────────────────────────────────────────────────────────┤ │
│ │ TETHERED IPC BRIDGE │ │
│ │ WebSocket ↔ Chrome extension, message queue, │ │
│ │ heartbeat, auto-reconnect, stale detection │ │
│ │ │ │
│ │ ↳ Absorbs: connection drops, tab refreshes, │ │
│ │ port conflicts, extension lifecycle │ │
│ ├────────────────────────────────────────────────────────────┤ │
│ │ COMMAND CHANNEL │ │
│ │ bridge.send → CDP browser control via the extension │ │
│ │ crawlio.* → Crawlio HTTP endpoints │ │
│ │ Live searchable catalog: browser + Crawlio HTTP │ │
│ └────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌───────────────────────────────────┐
│ Live Chrome Browser │
│ Persistent session, real DOM, │
│ framework runtime, user state │
└───────────────────────────────────┘
search("page capture performance") and gets documentation for relevant commandssmart object with appropriate namespacesbridge (the browser command channel), crawlio (HTTP client), sleep, TIMEOUTS, smart (7 core + 18 higher-order methods + up to 17 framework namespaces), compileRecordingextractPage() fires 7 parallel bridge.send() calls; click() runs the actionability engine; react.getVersion() evaluates framework-specific expressionsexecute again. Framework cache persists — no re-detection unless URL changedCode Mode is Cloudflare's idea and a good one: present tools as a typed API and let the model write code against it, because models have seen far more code than tool calls. Crawlio Browser applies that pattern to a target it was not built for — a live browser holding your session. This is an MCP server, not an alternative to MCP.
The row that matters is error recovery. An isolate is disposable by design — that is what makes it safe to run untrusted code, and it means a failure discards the state that caused it. Here execution is tethered to a real tab, so when code fails the browser is still sitting in exactly the situation that broke it: same scroll position, same modal, same half-filled form. The model reads the error and runs again against that. Neither approach is better in general; they are answers to different problems, and the sandboxing guarantees Cloudflare gets from V8 isolates are genuinely stronger than what a local async sandbox provides.
Collapses 150 tools into four high-level tools, plus get_job_result,
list_jobs, and cancel_job for async execution — so tools/list reports
7.
That makes the tools/list payload 85% smaller, measured by
serializing the result each mode actually returns rather than estimated from a tool count. Code
mode is not free: execute and search carry long descriptions, so the measured reduction is
smaller than a naive tools-only ratio suggests. Check it yourself — npx crawlio-browser tools --json prints both surfaces without connecting to anything.
// Navigate and screenshot
await bridge.send({ type: 'browser_navigate', url: 'https://example.com' }, 30000);
await sleep(2000);
const screenshot = await bridge.send({ type: 'take_screenshot' }, 10000);
return screenshot;
Every tool exposed directly to the LLM. Enable with --full:
npx crawlio-browser init --full
In Code Mode, the smart object provides framework-aware helpers with auto-waiting and actionability checks.
Methods for structured analysis findings with confidence propagation:
When a finding's dimension matches an active coverage gap, confidence is automatically capped:
When a framework is detected, the smart object exposes framework-specific helpers:
Code Mode asks the model to write code. Method Mode gives that code a tested vocabulary: 18 higher-order methods that encode the multi-step patterns a model would otherwise improvise.
await smart.extractTable(selector) // not a hand-rolled scrape loop
await smart.scrollCapture() // not a guessed scroll cadence
It is a domain layer over Code Mode, not a replacement: the tool surface does not change, the
model still sees the same four primary tools, and the same 182-command
catalog sits underneath. What changes is what happens inside execute.
The surface is assembled per page. Detection recognizes 64
frameworks and attaches up to 17 matching namespaces, so smart.react.*
exists only where React does — the model never has to ask what the page is built with, or guess
at hook paths and fiber internals to find out.
And because execution is tethered to a live tab rather than a disposable isolate, a failure leaves the browser in the exact state that produced it. The model reads the structured error and runs again against that state, rather than rebuilding the situation from scratch.
┌────────────────────────────────────────────────────────────┐
│ execute sandbox │
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Behavioral Protocol (web-research skill) │ │
│ │ Acquire → Normalize → Analyze │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ Evidence Infrastructure │ │
│ │ finding() · findings() · clearFindings() │ │
│ │ Typed records · Coverage gaps · Confidence prop. │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ Higher-Order Methods [18] │ │
│ │ scrollCapture · waitForIdle · extractPage · │ │
│ │ comparePages · detectTables · extractTable · │ │
│ │ waitForNetworkIdle · extractData · detectSections · │ │
│ │ detectTechnologies · parseTrackingPixels · ... │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ Smart Core [7 methods] │ │
│ │ evaluate · click · type · navigate · waitFor · │ │
│ │ snapshot · rebuild │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ Framework Namespaces [up to 17, attached per page] │ │
│ │ react · vue · angular · nextjs · shopify · ... │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ bridge.send() — the browser command channel │ │
│ └──────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────┘
Each layer up encodes more domain knowledge. bridge.send({ type: "capture_page" }) captures a page. smart.extractPage() captures a page AND runs performance metrics, security state, font detection, accessibility analysis, and mobile-readiness checks in parallel — seven operations, one call, graceful failure on supplementary data, typed gaps for anything that fails.
Coverage Gaps — When supplementary operations in extractPage() fail, they don't silently return null. A typed gap is recorded with the dimension, reason, impact, and whether it reduces confidence on related findings:
// Example gap from a failed performance metrics call
{ dimension: "performance", reason: "CDP domain disabled", impact: "method-failed", reducesConfidence: true }
Tool-Enforced Findings — smart.finding() validates every field at the tool level. The model cannot produce a finding without meeting the schema — it either returns a valid Finding or gets a clear error. Findings accumulate across execute calls within a session via smart.findings().
Session Aggregation — Findings and coverage gaps persist across execute calls. A model can make findings across multiple calls, then retrieve the full set with smart.findings(). Reset with smart.clearFindings().
// 1. Extract and compare both sites (scaffold + gaps included)
const comparison = await smart.comparePages(
'https://acme.com',
'https://rival.com'
);
// 2. Make findings — confidence auto-adjusts based on data availability
smart.finding({
claim: 'Rival loads 2.3x faster on Largest Contentful Paint',
evidence: [
`Acme LCP: ${comparison.siteA.performance?.webVitals?.lcp}ms`,
`Rival LCP: ${comparison.siteB.performance?.webVitals?.lcp}ms`,
],
sourceUrl: 'https://acme.com',
confidence: 'high',
method: 'comparePages + extractPage performance metrics',
dimension: 'performance', // if perf data failed, confidence caps to "medium"
});
smart.finding({
claim: 'Acme has 12 images without alt text; Rival has 0',
evidence: [
`Acme imagesWithoutAlt: ${comparison.siteA.accessibility?.imagesWithoutAlt}`,
`Rival imagesWithoutAlt: ${comparison.siteB.accessibility?.imagesWithoutAlt}`,
],
sourceUrl: 'https://acme.com',
confidence: 'high',
method: 'comparePages + extractPage accessibility summary',
dimension: 'accessibility',
});
// 3. Capture visual evidence
await smart.navigate('https://acme.com');
await smart.waitForIdle();
const acmeVisuals = await smart.scrollCapture({ maxSections: 5 });
// 4. Return accumulated session findings + visual evidence
return {
findings: smart.findings(),
scaffold: comparison.scaffold,
gaps: { acme: comparison.siteA.gaps, rival: comparison.siteB.gaps },
visualEvidence: { acme: acmeVisuals.sectionCount + ' sections captured' },
};
// Connect to active tab, extract structured page evidence
const page = await smart.extractPage();
const finding = smart.finding({
claim: `Site uses ${page.capture.framework?.name || 'no detected framework'}`,
evidence: [`Framework: ${JSON.stringify(page.capture.framework)}`],
sourceUrl: page.meta?.canonical || 'active tab',
confidence: 'high',
method: 'extractPage framework detection',
});
return { page: page.meta, finding };
// Emulate iPhone and capture
await bridge.send({ type: 'emulate_device', device: 'iPhone 14' }, 10000);
await smart.navigate('https://example.com');
await smart.waitForIdle();
const screenshot = await bridge.send({ type: 'take_screenshot' }, 10000);
return screenshot;
// Record a browser session, then compile to reusable skill
await bridge.send({ type: 'start_recording' }, 10000);
await smart.navigate('https://example.com');
await smart.click('button.submit');
await smart.type('#email', '[email protected]');
const session = await bridge.send({ type: 'stop_recording' }, 10000);
return compileRecording(session.session, 'signup-flow');
// Block analytics, mock API response
await bridge.send({
type: 'browser_intercept',
pattern: '*analytics*',
action: 'block'
}, 10000);
await bridge.send({
type: 'browser_intercept',
pattern: '*/api/user',
action: 'mock',
body: JSON.stringify({ name: 'Test User' }),
statusCode: 200
}, 10000);
await smart.navigate('https://example.com');
return await smart.snapshot();
Record browser sessions as structured data, then compile them into reusable automation skills. 12 interaction tools are automatically intercepted during recording (click, type, navigate, scroll, etc.), capturing args, result, timing, and page URL.
// In code mode: record, interact, compile
await bridge.send({ type: 'start_recording' }, 10000);
// ... interact with the page ...
const session = await bridge.send({ type: 'stop_recording' }, 10000);
const skill = compileRecording(session.session, 'my-automation');
return skill;
In full mode, recording is available as 4 individual tools: start_recording, stop_recording, get_recording_status, and compile_recording.
Mutative tools (browser_click, browser_type, browser_navigate, browser_select_option) use actionability checks:
[0, 20, 100, 100, 500]msThis means the AI doesn't need to manually add sleep() or waitFor() calls between actions — the tools handle SPA rendering delays automatically.
Detects 64 technologies across 4 tiers using globals, DOM markers, meta tags, HTTP headers, and script URLs:
Multi-framework detection returns a primary framework (meta-framework takes priority) plus a subFrameworks array for the full stack.
The table below is a hand-written guide to the commonly used tools, not the complete set. For
the full, current surface — all 150 of them, read from the server itself —
run npx crawlio-browser tools --full.
Optional — requires Crawlio.app running locally.
ControlServer authentication is automatic and local-only: the MCP reads CRAWLIO_MCP_TOKEN when
explicitly set, otherwise Crawlio.app's mode-0600 ~/Library/Logs/Crawlio/mcp.token, and sends it
only to the discovered 127.0.0.1 ControlServer. The value is never returned in MCP results or
written to logs.
The production extension has no standing host access. Its required permissions are debugger
(the CDP control plane), storage (bridge/session settings and durable resident metadata), and
alarms (reconnect, idle-release, and resident monitor wakeups). The dedicated onboarding page
asks once for every optional capability declared by the active build. In production that is tabs,
nativeMessaging, and http://127.0.0.1/*, covering tab discovery/adoption, authenticated local
token provisioning, and loopback bridge discovery.
Onboarding is the only surface that can open Chrome's permission prompt. The extension popup and
MCP tools only report missing access and route the user back to onboarding. connect_tab({url}),
agent-owned tabs, robot training, and resident monitoring can still create and control their own
tabs if the tabs metadata grant is denied. Crawlio does not request <all_urls>, activeTab,
tabGroups, or unlimitedStorage.
git clone https://github.com/Crawlio-app/crawlio-browser.git
cd crawlio-browser
npm install
npm run build # selectors → semantic-grounding → MCP server → extension
Build output lands in dist/mcp-server/ (ESM bundle) and dist/extension/ (the
unpacked MV3 extension).
To develop against the extension, build the dev variant and load it unpacked:
npm run build:dev # → dist/extension-dev, with __DEV__ logging enabled
Then open chrome://extensions, enable Developer mode, choose Load unpacked,
and select dist/extension-dev. Reload the extension there after each rebuild.
npm test # vitest
npm run typecheck # server + extension TypeScript projects
Contributions are welcome — see CONTRIBUTING.md for the build and development loop, and CODE_OF_CONDUCT.md for community expectations. Please report security vulnerabilities privately via SECURITY.md rather than in a public issue.
Apache-2.0 — see LICENSE.
The selector kernel in packages/selectors is MIT-licensed:
it contains code ported from Selector Forge (MIT) and Chromium DevTools
(BSD-3-Clause). See packages/selectors/LICENSE and
THIRD_PARTY_NOTICES.md for full attributions.
Bridge a live Chrome browser to your agent: 150 tools for capture, extraction, and observation.
{ "mcpServers": { "app.crawlio-crawlio-browser": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
Crawlio Browser läuft lokal über stdio.
Zuletzt geprüft: 2026-11-07. Bridge a live Chrome browser to your agent: 150 tools for capture, extraction, and observation.