Skip to main content
Glama

MCP Fetch Page

Browser-based web page fetching with automatic cookie support and CSS selector extraction.

Features

  • 🤖 Browser Automation: Full JavaScript rendering with Puppeteer

  • 🍪 Automatic Cookie Management: Loads all saved cookies automatically

  • 🎯 CSS Selector Support: Extract specific content with selectors

  • 🌐 Domain Presets: Built-in selectors for common websites

  • 📱 SPA Support: Fully supports dynamic content and AJAX

Related MCP server: ScrapeLab MCP

Quick Start

1. Configure MCP Server

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "mcp-fetch-page": {
      "command": "npx",
      "args": ["-y", "mcp-fetch-page@latest"]
    }
  }
}

To customize runtime data directory (recommended on VPS), set MCP_FETCH_PAGE_DATA_DIR in MCP env:

{
  "mcpServers": {
    "mcp-fetch-page": {
      "command": "npx",
      "args": ["-y", "mcp-fetch-page@latest"],
      "env": {
        "MCP_FETCH_PAGE_DATA_DIR": "/data/mcp-fetch-page"
      }
    }
  }
}

Restart Claude Desktop.

2. Install Chrome Extension (Optional - for authenticated pages)

Download and install the Chrome extension to save cookies from authenticated sessions:

📥 Download Extension from Releases

Installation steps:

  1. Download mcp-fetch-page-extension-vX.X.X.zip from the latest release

  2. Unzip the file

  3. Open Chrome and go to chrome://extensions/

  4. Enable "Developer mode" (top right)

  5. Click "Load unpacked" and select the unzipped folder

Usage

Basic Usage

  1. Login to a website in Chrome

  2. Click the "Fetch Page MCP Tools" extension icon

  3. Click "Save Cookies" button

  4. Use in Claude/Cursor: fetchpage(url="https://example.com")

Advanced Usage

// Basic fetching with automatic cookie loading
fetchpage(url="https://example.com")

// Extract specific content with CSS selector
fetchpage(url="https://example.com", waitFor="#main-content")

// WeChat articles (automatic selector)
fetchpage(url="https://mp.weixin.qq.com/s/xxxxx")

// Run in non-headless mode for debugging
fetchpage(url="https://example.com", headless=false)

Domain Presets

The system automatically uses optimized selectors for:

  • mp.weixin.qq.com.rich_media_wrp (WeChat articles)

  • wx.zsxq.com.content (Knowledge Planet)

  • cnblogs.com.post (Blog Garden)

  • Add more in mcp-server/domain-rules.json (domain-selectors.json remains supported for compatibility)

Debug Tools

# Standalone debug script (recommended for development)
cd mcp-server
node debug.js test-page "https://example.com"
node debug.js test-spa "https://example.com" "#content"

# MCP Inspector (for integration testing)
npx @modelcontextprotocol/inspector
# Then visit http://localhost:6274

Data Directory (Optional)

By default, runtime data is stored under ~/Downloads/mcp-fetch-page/:

  • Cookies: ~/Downloads/mcp-fetch-page/cookies

  • Pages: ~/Downloads/mcp-fetch-page/pages

For MCP usage, configure MCP_FETCH_PAGE_DATA_DIR in your MCP client config env field. The server will always use:

  • <MCP_FETCH_PAGE_DATA_DIR>/cookies

  • <MCP_FETCH_PAGE_DATA_DIR>/pages

  • <MCP_FETCH_PAGE_DATA_DIR>/domain-rules.json (optional user overrides merged with built-in rules)

node mcp-server/server.js is only for local development/debugging.

Parameters

  • url (required): The URL to fetch

  • waitFor (optional): CSS selector to extract specific content

  • headless (optional): Run browser in headless mode (default: true)

  • timeout (optional): Timeout in milliseconds (default: 30000)

File Structure

mcp-fetch-page/
├── package.json              # npm package config
├── package-lock.json         # npm lockfile
├── node_modules/             # npm dependencies
├── README.md                 # This file
├── README-zh.md              # Chinese version
├── CLAUDE.md                 # Claude Code usage guide
├── chrome-extension/         # Chrome extension
│   ├── manifest.json
│   ├── popup.js
│   ├── popup.html
│   └── background.js
└── mcp-server/              # MCP server
    ├── server.js            # Main server
    ├── debug.js             # Debug tools
    ├── domain-rules.json     # Domain rules config (selector + blocked markers)
    └── domain-selectors.json # Legacy selector config (compatibility fallback)

Troubleshooting

  • Extension not working: Make sure you're on a normal website (not chrome:// pages)

  • No cookies found: Try logging in again and saving cookies

  • MCP not connecting: Check Node.js installation and restart your editor

  • Path error: Set MCP_FETCH_PAGE_DATA_DIR in MCP config env to a writable absolute path on your machine/VPS

  • CSS selector not working: Verify the selector exists on the page

That's it! 🍪

Available Tools

1 tool
fetchpageA

Fetch web pages using browser automation with full JavaScript rendering. Supports automatic cookie management, localStorage, CSS selectors, and dynamic content. Cookies are automatically loaded from local storage if available.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesThe URL to fetch
timeoutNoTimeout in milliseconds (default: 30000)
waitForNoCSS selector to extract specific content only (optional, extracts only content within this selector)
headlessNoRun browser in headless mode (optional, default: true)

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses automatic cookie loading from local storage and JS rendering, but omits details like error handling, detection risks, or headless default behavior (default true is only in schema).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences with the primary action front-loaded. No redundant information; every phrase adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 4 parameters and no output schema, the description covers core functionality (browser automation, JS rendering, cookie management) but lacks details on output format or error behavior. Still, it is largely complete for a web-fetch tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

All 4 parameters have schema descriptions (100% coverage), so the description adds minimal extra meaning. It mentions CSS selectors and dynamic content, which align with waitFor and headless, but does not significantly enhance the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it fetches web pages with browser automation and full JavaScript rendering, distinguishing it from simple HTTP fetches. It lists specific capabilities (cookie management, localStorage, CSS selectors, dynamic content) that narrow its purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for pages requiring JavaScript rendering but provides no explicit when-to-use or when-not-to-use guidance. No sibling tools are listed, so direct comparison is absent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

  1. 1 tool updatev0.5.0
    • First observedfetchpage

TDQS

A3.9/5.0

Scored across 1 tool

Disambiguation5/5

With only one tool, there is no ambiguity. The tool has a clear and distinct purpose.

Naming Consistency5/5

Single tool 'fetchpage' follows a clear verb_noun pattern (fetch + page), consistent with itself.

Tool Count3/5

One tool is borderline for a server; it serves a focused purpose but lacks any auxiliary tools, making it thin.

Completeness4/5

The tool covers the core functionality of fetching pages with JS rendering and cookie management; minor gaps like explicit session listing exist but are not critical.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    A
    maintenance
    Fetches content from authenticated web pages by driving your signed-in Chrome/Edge browser via DevTools Protocol, automatically handling login redirects and reusing sessions across domains.
    8
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables undetectable web scraping and browser automation for AI agents with 84 tools including stealth navigation, element extraction, network interception, and auto cookie consent dismissal. Bypasses anti-bot systems like Cloudflare and DataDome while providing LLM-ready markdown output and full Chrome DevTools Protocol access.
    MIT
  • A
    license
    B
    quality
    F
    maintenance
    Enables AI agents to directly control your real Chrome browser with full context including login sessions, cookies, and open tabs. It provides tools for page scanning, JavaScript execution, CDP control, screenshots, and physical mouse/keyboard input for authentic browser automation.
    20
    243
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables LLMs to fetch and extract web content using browser automation, OCR, and multiple extraction methods, handling JavaScript rendering and anti-scraping techniques.
    17
    MIT