Which integrations are available for this server?

Supports using CSS selectors to target and extract specific elements or regions from web pages during the fetching process. Converts web content from any URL into clean, token-efficient Markdown, stripping away navigation, ads, and boilerplate code for LLM consumption.

stripfeed-mcp-server

Official

by StripFeed

Overview Schema Related Servers Score Discussions

JavaScript

Remote

StripFeed MCP Server

npm version License: MIT

MCP server for StripFeed - convert any URL to clean, token-efficient Markdown.

Works with Claude Code, Cursor, Windsurf, and any MCP-compatible client.

Setup

1. Get your API key

2. Install

Claude Code

claude mcp add stripfeed -- npx -y @stripfeed/mcp-server

Then set your API key:

export STRIPFEED_API_KEY=sf_live_your_key

Or add it to your shell profile (~/.zshrc, ~/.bashrc).

Cursor / VS Code

Add to your MCP settings (.cursor/mcp.json or VS Code MCP config):

{
  "mcpServers": {
    "stripfeed": {
      "command": "npx",
      "args": ["-y", "@stripfeed/mcp-server"],
      "env": {
        "STRIPFEED_API_KEY": "sf_live_your_key"
      }
    }
  }
}

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "stripfeed": {
      "command": "npx",
      "args": ["-y", "@stripfeed/mcp-server"],
      "env": {
        "STRIPFEED_API_KEY": "sf_live_your_key"
      }
    }
  }
}

Tools

`fetch_url`

Convert a single URL to clean Markdown. Strips ads, navigation, scripts, and boilerplate. Returns clean content ready for LLM consumption.

Parameters:

Parameter	Type	Required	Description
url	string	Yes	URL to fetch and convert (http/https)
format	string	No	Output format: `markdown` (default), `json`, `text`, `html`
selector	string	No	CSS selector to extract specific elements (e.g. `article`, `.content`, `#main`)
model	string	No	AI model ID for cost tracking (e.g. `claude-sonnet-4-6`)
cache	boolean	No	Set to `false` to bypass cache and force fresh fetch
ttl	number	No	Cache TTL in seconds (default 3600, max 86400)
max_tokens	number	No	Truncate output to fit within this token budget (positive integer)

Example: Basic fetch

Prompt: "Fetch https://react.dev/learn and summarize the key concepts"

The tool calls fetch_url with url: "https://react.dev/learn" and returns:

Title: Quick Start - React | Tokens: 2,450 (saved 91.2% from 27,840) | Cache: MISS | Fetch: 342ms

---

# Quick Start

Welcome to the React documentation! This page will give you an introduction to 80% of the React concepts...

Example: Extract with CSS selector

Prompt: "Get the pricing table from https://stripe.com/pricing using selector '.pricing-table'"

The tool calls fetch_url with url: "https://stripe.com/pricing" and selector: ".pricing-table" and returns only the content matching that CSS selector.

Example: Plain text output

Prompt: "Fetch https://example.com as plain text"

The tool calls fetch_url with url: "https://example.com" and format: "text". Returns plain text with all Markdown formatting stripped (no headings, bold, links, etc.).

Example: Truncate to token budget

Prompt: "Fetch https://en.wikipedia.org/wiki/Rust_(programming_language) but limit to 500 tokens"

The tool calls fetch_url with url: "https://en.wikipedia.org/wiki/Rust_(programming_language)" and max_tokens: 500. The output is truncated at a paragraph or sentence boundary to fit within 500 tokens. The response metadata shows Truncated: yes.

Example: Custom cache TTL

Prompt: "Fetch https://news.ycombinator.com with a 2-hour cache"

The tool calls fetch_url with url: "https://news.ycombinator.com" and ttl: 7200. The content is cached for 7200 seconds (2 hours) instead of the default 3600 (1 hour). Subsequent requests within that window return instantly from cache.

Example: Bypass cache

Prompt: "Fetch https://news.ycombinator.com with fresh content, don't use cache"

The tool calls fetch_url with url: "https://news.ycombinator.com" and cache: false. Forces a fresh fetch even if cached content exists.

`batch_fetch`

Fetch multiple URLs in parallel and convert them all to clean Markdown. Process up to 10 URLs in a single call. Requires Pro plan.

Parameters:

Parameter	Type	Required	Description
urls	string[]	Yes	Array of URLs to fetch (1-10)
model	string	No	AI model ID for cost tracking

Example: Compare multiple pages

Prompt: "Fetch the React, Vue, and Svelte docs and compare their approaches to state management"

The tool calls batch_fetch with urls: ["https://react.dev/learn", "https://vuejs.org/guide/introduction.html", "https://svelte.dev/docs/introduction"] and returns all three pages as Markdown sections:

Fetched 3/3 URLs successfully.

---

## Quick Start - React

Source: https://react.dev/learn | 2,450 tokens (saved 91.2% from 27,840)

# Quick Start
...

---

## Introduction - Vue.js

Source: https://vuejs.org/guide/introduction.html | 1,890 tokens (saved 88.5% from 16,400)

# Introduction
...

---

## Introduction / Svelte

Source: https://svelte.dev/docs/introduction | 1,120 tokens (saved 93.1% from 16,200)

# Introduction
...

Handling failures: If a URL fails (unreachable, timeout, invalid), it gets a per-item error and the other URLs still succeed:

Fetched 2/3 URLs successfully.

---

## Quick Start - React

Source: https://react.dev/learn | 2,450 tokens (saved 91.2% from 27,840)

# Quick Start
...

---

## https://invalid-url.example

Error: Target URL unreachable

---

## Introduction - Vue.js

Source: https://vuejs.org/guide/introduction.html | 1,890 tokens (saved 88.5% from 16,400)

# Introduction
...

Note on selectors: The batch_fetch tool sends plain URL strings. To use CSS selectors on individual URLs in a batch, use the REST API directly:

curl -X POST "https://www.stripfeed.dev/api/v1/batch" \
  -H "Authorization: Bearer sf_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": [
      "https://example.com",
      {"url": "https://docs.anthropic.com", "selector": "article"},
      {"url": "https://stripe.com/pricing", "selector": ".pricing-table"}
    ]
  }'

Each URL item in the array can be a plain string or an object with url and optional selector.

Strategy: Efficient batch_fetch for Product Pages with Minimal Token Usage

To efficiently extract only relevant information from a list of product pages while minimizing token usage for an AI model, combine batch_fetch with these strategies:

Step 1: Use batch_fetch to fetch all pages at once

Call batch_fetch with all product URLs (up to 10 per call):

batch_fetch with urls: [
  "https://example.com/product/a",
  "https://example.com/product/b",
  "https://example.com/product/c",
  "https://example.com/product/d",
  "https://example.com/product/e"
]

This fetches all 5 pages in parallel in a single API call, rather than 5 sequential fetch_url calls.

Step 2: If pages are too large, re-fetch with selectors via the REST API

If batch_fetch returns pages with high token counts (e.g., 10K+ tokens each), use the REST API batch endpoint with per-URL CSS selectors to extract only the product section:

curl -X POST "https://www.stripfeed.dev/api/v1/batch" \
  -H "Authorization: Bearer sf_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": [
      {"url": "https://example.com/product/a", "selector": ".product-details"},
      {"url": "https://example.com/product/b", "selector": ".product-details"},
      {"url": "https://example.com/product/c", "selector": ".product-details"}
    ],
    "model": "claude-sonnet-4-6"
  }'

Step 3: Use max_tokens on individual pages if still too large

For pages that are still large after selector extraction, use fetch_url with max_tokens to cap the output:

fetch_url with url: "https://example.com/product/a", selector: ".product-details", max_tokens: 1000

This truncates at a paragraph or sentence boundary to stay within 1,000 tokens.

Token savings summary:

Raw HTML page: ~15,000 tokens
After StripFeed Markdown conversion: ~1,500 tokens (90% saved)
With CSS selector: ~500 tokens (97% saved)
With selector + max_tokens: ~200 tokens (99% saved)

Monitoring usage: Call check_usage before and after batch operations to track how many API requests you have remaining on your plan.

`check_usage`

Check your current monthly API usage and plan limits. Takes no parameters.

Example response:

Plan: pro
Usage: 1,250 / 100,000
Remaining: 98,750
Resets: 2026-04-01T00:00:00.000Z

For free plan users:

Plan: free
Usage: 42 / 200
Remaining: 158
Resets: 2026-04-01T00:00:00.000Z

For enterprise plan users (unlimited):

Plan: enterprise
Usage: 54,200 (unlimited)
Resets: 2026-04-01T00:00:00.000Z

Handling fetch_url Failures and Empty Results

When fetch_url fails to process a URL or returns empty content, the MCP server throws an error with a specific status code and message. Here is how an MCP client should interpret and handle each failure mode:

Network and target failures:

Status	Error Message	What Happened	Client Action
502	`Target URL unreachable`	The target website is down or DNS failed	Retry after a delay, or inform the user the site is unavailable
504	`Target URL timed out`	The target took longer than 10 seconds to respond	Retry once, then fall back to a cached version or inform the user

Input validation failures (do not retry):

Status	Error Message	What Happened	Client Action
422	`Invalid URL`	The URL is malformed or not http/https	Fix the URL and try again
422	`No content found matching selector`	The CSS selector matched zero elements on the page	Try without a selector, or use a different selector
422	`Invalid format parameter`	The format value is not one of: markdown, json, text, html	Fix the format parameter
422	`Invalid max_tokens parameter`	max_tokens is not a positive integer	Fix the parameter value

Auth and rate limit failures:

Status	Error Message	What Happened	Client Action
401	`Missing or invalid Authorization header`	The API key is missing or invalid	Check the STRIPFEED_API_KEY environment variable
429	`Rate limit exceeded`	More than 20 requests per second	Wait 1 second and retry
429	`Monthly quota exceeded`	Plan limit reached for the month	Call `check_usage` to confirm, then upgrade or wait for reset

Empty results: If fetch_url succeeds (no error thrown) but the returned Markdown content is very short or empty, this means the target page had no extractable main content (e.g., a page with only images, or a JavaScript-rendered SPA with no server-side HTML). In this case:

Try using a CSS selector to target a specific element
Try fetching with format: "html" to see the raw extracted HTML
The page may require JavaScript rendering (not currently supported)

Retry strategy for MCP clients:

Retryable errors (502, 504, 429 rate limit): Retry up to 2 times with exponential backoff (1s, 3s)
Non-retryable errors (401, 422, 429 quota): Do not retry. Fix the input or check configuration.
Successful but empty: Try alternative selectors or inform the user the page has no extractable content

Error Handling

The MCP server returns clear error messages when something goes wrong:

Error	Cause	Resolution
`STRIPFEED_API_KEY environment variable is required`	Missing API key	Set `STRIPFEED_API_KEY` env var
`StripFeed API error 401: Missing or invalid Authorization header`	Invalid API key	Check your key at dashboard/keys
`StripFeed API error 422: Invalid URL`	Bad URL parameter	Ensure URL starts with http:// or https://
`StripFeed API error 422: No content found matching selector`	CSS selector matched nothing	Check the selector against the page's HTML
`StripFeed API error 429: Rate limit exceeded`	Too many requests	Wait for the rate limit window to reset (20 req/s burst)
`StripFeed API error 429: Monthly quota exceeded`	Plan limit reached	Upgrade to Pro or wait for monthly reset
`StripFeed API error 502: Target URL unreachable`	Target site is down	Try again later or check the URL
`StripFeed API error 504: Target URL timed out`	Target took >10s to respond	The target site is slow, try again later

REST API

The MCP server wraps the StripFeed REST API. You can also call the API directly:

# Single URL fetch (returns Markdown)
curl "https://www.stripfeed.dev/api/v1/fetch?url=https://news.ycombinator.com" \
  -H "Authorization: Bearer sf_live_your_key"

# With options: JSON format, CSS selector, max 500 tokens
curl "https://www.stripfeed.dev/api/v1/fetch?url=https://example.com&format=json&selector=article&max_tokens=500" \
  -H "Authorization: Bearer sf_live_your_key"

# Batch fetch (up to 10 URLs, with per-URL selectors)
curl -X POST "https://www.stripfeed.dev/api/v1/batch" \
  -H "Authorization: Bearer sf_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://news.ycombinator.com", {"url": "https://docs.anthropic.com", "selector": "article"}]}'

# Check usage
curl "https://www.stripfeed.dev/api/v1/usage" \
  -H "Authorization: Bearer sf_live_your_key"

JSON response format (when format=json):

{
  "markdown": "# Page Title\n\nClean content here...",
  "html": "<article>...</article>",
  "text": "Plain text version...",
  "url": "https://example.com",
  "title": "Page Title",
  "tokens": 1250,
  "originalTokens": 14200,
  "savingsPercent": 91.2,
  "cached": false,
  "fetchMs": 342,
  "format": "json",
  "truncated": false,
  "selector": "article",
  "model": null
}

Response headers (included with every response):

Header	Description
`X-StripFeed-Tokens`	Token count of clean output
`X-StripFeed-Original-Tokens`	Token count of original HTML
`X-StripFeed-Savings-Percent`	Percentage of tokens saved
`X-StripFeed-Cache`	`HIT` or `MISS`
`X-StripFeed-Fetch-Ms`	Processing time in ms (0 for cache hits)
`X-StripFeed-Truncated`	`true` when max_tokens caused truncation

Usage response:

{
  "plan": "pro",
  "usage": 1250,
  "limit": 100000,
  "remaining": 98750,
  "resetsAt": "2026-04-01T00:00:00.000Z"
}

SDKs

For programmatic access without MCP, use the official SDKs:

TypeScript/JavaScript:

import StripFeed from "stripfeed";

const sf = new StripFeed("sf_live_your_key");

// Fetch a URL
const result = await sf.fetch("https://example.com");
console.log(result.markdown);
console.log(`Tokens: ${result.tokens} (saved ${result.savingsPercent}%)`);

// With options
const article = await sf.fetch("https://example.com", {
  selector: "article",
  maxTokens: 500,
  ttl: 7200,
});

// Batch fetch
const batch = await sf.batch(["https://a.com", "https://b.com"]);

// Check usage
const usage = await sf.usage();
console.log(`${usage.usage} / ${usage.limit} requests used`);

npm: https://www.npmjs.com/package/stripfeed

Python:

from stripfeed import StripFeed

sf = StripFeed("sf_live_your_key")

# Fetch a URL
result = sf.fetch("https://example.com")
print(result["markdown"])
print(f"Tokens: {result['tokens']} (saved {result['savingsPercent']}%)")

# With options
article = sf.fetch("https://example.com", selector="article", max_tokens=500, ttl=7200)

# Batch fetch
batch = sf.batch(["https://a.com", "https://b.com"])

# Check usage
usage = sf.usage()
print(f"{usage['usage']} / {usage['limit']} requests used")

PyPI: https://pypi.org/project/stripfeed/

Pricing

The MCP server uses your StripFeed API key. Usage counts toward your plan limits:

Plan	Price	Requests/month	API Keys
Free	$0	200	1
Pro	$19/mo	100,000	Unlimited
Enterprise	Custom	Unlimited	Unlimited

License

MIT

Available Tools

3 tools

batch_fetchB

Fetch multiple URLs in parallel and convert them all to clean Markdown. Process up to 10 URLs in a single call.

ParametersJSON Schema

Name	Required	Description	Default
`urls`	Yes	Array of URLs to fetch (1-10)
`model`	No	AI model ID for cost tracking

TDQS

B3.2/5.0

Behavior2/5

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

With no annotations, the description must fully disclose behavior. It mentions parallel processing and a limit of 10 URLs, but lacks details on error handling, authentication, rate limiting, or output format. Incomplete for a batch operation.

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 sentences with no fluff. Front-loaded with the main action. Every sentence serves a purpose.

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

Completeness2/5

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

Given the complexity of batch fetching (parallel, multiple URLs, conversion), the description is insufficient. Missing details on output format, error propagation, and concurrency behavior. No output schema exists to compensate.

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?

Schema coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema; it only restates the parameters without extra context.

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 the verb 'Fetch', the resource 'multiple URLs', and the output 'clean Markdown'. It distinguishes from sibling 'fetch_url' by indicating parallel processing of multiple URLs.

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

Usage Guidelines2/5

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

No guidance on when to use this tool vs alternatives like fetch_url or check_usage. Does not specify when not to use it or any prerequisites.

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

check_usageA

Check your current monthly API usage and plan limits.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A3.7/5.0

Behavior2/5

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

No annotations are provided, so the description should disclose behavioral traits. It only states the tool checks usage but does not mention authentication needs, data sensitivity, rate limits, or whether it is read-only. This is insufficient for a tool with no annotation support.

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?

The description is a single, concise sentence with no redundancy or unnecessary information. Every word serves a purpose.

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

Completeness3/5

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

The description is adequate for a simple check tool but lacks any mention of the response format, possible errors, or additional context that would help the agent interpret results. No output schema is provided to compensate.

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

Parameters4/5

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

The tool has zero parameters, and schema coverage is 100% by definition. The description does not need to explain parameters, meeting the baseline for no-parameter tools.

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 the tool's action ('Check') and the resource ('current monthly API usage and plan limits'). It is specific and distinct from sibling tools (batch_fetch, fetch_url) which focus on data retrieval.

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 usage for checking usage limits but provides no explicit guidance on when to use this tool versus siblings or any prerequisites. No context on alternatives or exclusions.

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

fetch_urlA

Convert any URL to clean, token-efficient Markdown. Strips ads, navigation, scripts, and noise. Returns clean content ready for LLM consumption.

ParametersJSON Schema

Name	Required	Description
`url`	Yes	The URL to fetch and convert to Markdown
`format`	No	Output format: markdown (default), json, text, html
`selector`	No	CSS selector to extract specific elements (e.g. 'article', '.content', '#main')
`model`	No	AI model ID for cost tracking (e.g. 'claude-sonnet-4-6', 'gpt-5')
`cache`	No	Set to false to bypass cache and force fresh fetch
`ttl`	No	Cache TTL in seconds (default 3600, max 86400)
`max_tokens`	No	Truncate output to fit within this token budget

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 that the tool strips ads/navigation/scripts and returns clean Markdown, but does not mention rate limits, authentication, error handling, or cost implications (despite a 'model' parameter for cost tracking).

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?

Three concise sentences with no wasted words: first states purpose, second explains noise stripping, third describes output. Information is front-loaded and easy to scan.

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?

For a fetch tool with 7 parameters, the description covers the main action and noise removal adequately. It lacks information on output type differences (markdown vs json vs text) and error behavior, but the schema handles parameter details. Sibling tools exist but no usage guidance.

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?

Input schema covers all 7 parameters with descriptions (100% coverage), so baseline is 3. The description adds no parameter-specific context beyond the overall conversion and noise stripping; it does not explain how format or selector affect output.

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 the tool converts any URL to Markdown, stripping ads and noise, which distinguishes it from siblings like batch_fetch (batch operations) and check_usage (usage tracking).

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 explains the tool's core function but provides no explicit guidance on when to use it over alternatives, nor does it mention when not to use it. The context is clear enough for a single-URL converter but lacks comparative advice.

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. Dates show when Glama detected each change.

3 tool updatesv1.1.0Mar 25, 2026
- First observedbatch_fetch
- First observedcheck_usage
- First observedfetch_url

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.7/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: batch_fetch handles multiple URLs in parallel, fetch_url processes a single URL, and check_usage monitors API usage. There is no overlap in functionality, making tool selection straightforward for an agent.

Naming Consistency5/5

All tool names follow a consistent snake_case verb_noun pattern (batch_fetch, check_usage, fetch_url), with clear and descriptive verbs that align with their actions. No deviations or mixed conventions are present.

Tool Count4/5

With 3 tools, the server is well-scoped for its purpose of URL fetching and usage monitoring, though it might feel slightly minimal for broader workflows. Each tool earns its place, but the count is on the lower end of typical ranges.

Completeness4/5

The toolset covers core operations for fetching URLs (single and batch) and checking usage, with no obvious gaps for the stated domain. Minor gaps might include advanced content processing or configuration options, but agents can work effectively with the provided tools.

Maintenance

ActivityNo data

ResponsivenessSyncing

Resources

Need Help?

Reddit Discussion

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

scrapi A
io.github.bamchi
Web scraping for AI agents. Converts URLs to clean, LLM-ready Markdown with anti-bot bypass.
Web Scraping Browser Automation Agent Orchestration
525
Onto
io.github.ravixalgorithm
Clean Markdown and AI-readability scoring for any URL. Built for AI agents.
11
anybrowse A
io.github.kc23go
Converts any URL to clean, LLM-ready Markdown using real Chrome browsers
Browser Automation Web Scraping Developer Tools
35
webscrape-mcp
io.github.carrasquelalex1
Fetch any URL and get clean Markdown. Web scraping for AI agents.
Web Scraping Browser Automation
21

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/StripFeed/mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

StripFeed MCP Server

Setup

1. Get your API key

2. Install

Claude Code

Cursor / VS Code

Claude Desktop

Tools

fetch_url

batch_fetch

Strategy: Efficient batch_fetch for Product Pages with Minimal Token Usage

check_usage

Handling fetch_url Failures and Empty Results

Error Handling

REST API

SDKs

Pricing

Links

License

Available Tools

TDQS

TDQS

TDQS

Tool Schema Changelog

TDQS

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Latest Blog Posts

MCP directory API

`fetch_url`

`batch_fetch`

`check_usage`