DeepLook 開源瀏覽器工具，使用 Chrome 並提供 CLI、HTTP API 與 MCP

I’m releasing DeepLook, an open-source browser tool that turns public web pages into readable text and structured data for AI agents.

It runs real Chrome, renders the page, and gives your application the visible text together with its title, final URL, HTTP status, and browser observations. You can use the same reading capability from a local CLI, a self-hosted HTTP API, or a coding agent through MCP.

The original project code is licensed under Apache-2.0. You can inspect it, run it on your own infrastructure, and contribute improvements.

The reading step in an agent’s workflow

Research and coding agents often need the actual page behind a URL. A lightweight HTTP fetch works for many sources; other pages need JavaScript rendering before useful text appears.

DeepLook handles that browser-reading step. Give it one public URL and consume the result in your own workflow. Search, research planning, deciding which links to follow, and writing a final answer remain your application’s responsibility.

I wanted the boundary to be easy to understand: a page request, a structured result, and an explicit error when the page cannot be read.

Try it locally

You need Node.js 22.14+ and Google Chrome. Local use does not require a DeepLook account, an LLM API key, or a shared project token.

git clone https://github.com/sayhitogambit/DeepLook.git
cd DeepLook
npm ci
npm run build

node dist/cli.js doctor --json
node dist/cli.js open https://example.com

Use JSON when your application needs page metadata, or the versioned machine format when you need a consistent success/error envelope:

node dist/cli.js open https://example.com --json
node dist/cli.js open https://example.com --machine --timeout-ms 30000

These commands install from GitHub source. They do not depend on a public npm registry release. You can also build and install your own tarball with npm pack.

Give your agent an MCP tool

DeepLook includes a stdio MCP server. After building the project, configure your MCP host to launch it:

{
  "mcpServers": {
    "deeplook": {
      "command": "node",
      "args": ["/absolute/path/to/DeepLook/dist/cli.js", "mcp"]
    }
  }
}

Configuration field names vary between hosts. The command exposes deeplook_open, which accepts a URL and an optional timeout:

{"url":"https://example.com","timeoutMs":30000}

Successful calls return page text and a structured result. Failed calls return a typed error. Each MCP process allows one active read, and cancellation propagates to the browser operation.

Page content remains untrusted input. An agent must treat instructions found inside a page as source material, rather than instructions from its user or developer.

Run your own HTTP API

DeepLook-API wraps the browser CLI with an HTTP interface, authentication, account quotas, concurrency limits, and lifecycle management.

Its page-reading endpoint is:

POST /v1/open
Authorization: Bearer <your-own-browser-key>
Content-Type: application/json

{"url":"https://example.com","timeoutMs":30000}

The API returns the page object on success. It reports errors such as invalid input, unauthorized access, an exhausted quota, a busy browser, a timeout, or a page that returned a challenge instead of useful content.

The operator generates and manages the server’s credentials. Administrator credentials and client browser keys have separate roles. There is no founder-owned token for everyone to share, and the source does not provide access to my accounts or infrastructure.

The credential guide walks through creating your own secrets and keeping them outside Git. The CLI and MCP tool can also connect to your own API through private environment variables.

What this first release promises

The project reads one public HTTP(S) URL per call. It uses stock Chrome and keeps its sandbox enabled. It checks outbound destinations, including redirects and page resources, and rejects private, local, and metadata addresses.

It also has clear limits:

It does not solve CAPTCHAs or promise access through bot checks, login walls, or paywalls.
It does not provide a general click-and-scroll agent or persistent browser sessions.
A successful Chrome executable diagnostic does not prove navigation, sandbox readiness, or a remote key’s permissions.
Application-level destination checks still need sensible deployment isolation and resource limits.

Those boundaries matter when you build an agent around a browser. The technical reference documents the response contract, errors, deadlines, cancellation, and cleanup behavior.

Built to be inspected and improved

The repositories include deterministic tests, tests with a real sandboxed browser, package-installation checks, and HTTP/container integration tests. They exercise practical failure cases as well as successful reads.

The README is available in English, Brazilian Portuguese, and Simplified Chinese. The DeepLook website will offer an optional newsletter with confirmation and unsubscribe links. The browser and API themselves do not require email credentials.

I’m opening the project early so developers can try real workflows, inspect the implementation, and help shape what comes next. Useful contributions include reproducible page-reading bugs, documentation improvements, platform testing, and agent integrations.

Start with the DeepLook repository, follow the getting-started guide, and tell me what you build.

This announcement was prepared with AI assistance and checked against the released project.