live · real MCP server
██╗    ██╗ ███╗   ███╗  ██████╗ ██████╗      ███████╗ ██╗  ██╗
██║    ██║ ████╗ ████║ ██╔════╝ ██╔══██╗     ██╔════╝ ██║  ██║
██║ █╗ ██║ ██╔████╔██║ ██║      ██████╔╝     ███████╗ ███████║
██║███╗██║ ██║╚██╔╝██║ ██║      ██╔═══╝      ╚════██║ ██╔══██║
╚███╔███╔╝ ██║ ╚═╝ ██║ ╚██████╗ ██║      ██╗ ███████║ ██║  ██║
 ╚══╝╚══╝  ╚═╝     ╚═╝  ╚═════╝ ╚═╝      ╚═╝ ╚══════╝ ╚═╝  ╚═╝

Turn any URL into agent-callable MCP tools.

A real, hosted MCP server. Paste any URL to get agent-callable tools — or connect it to Claude, Cursor, and Codex in one line. Shopify, OpenAPI, JSON-LD, and growing. Open-source adapters.

· URLs cached by the community · grows with every install
· MCP servers graded · live trust leaderboard
claude · cursor · codex — mcp
$ connect wmcp.sh/mcp/u/<any-url> → initialize protocol 2025-06-18 → tools/list get_price static list_variants static add_to_cart live → tools/call add_to_cart { variant: 41 } added — cart total $98

Paste a URL, get the tools.

APIs, storefronts, recipes, news, jobs, listings — any URL with structured data becomes agent-callable MCP tools. No signup, no key for reads. Bot-protected sites work through the WebMCP extension.

try: Twilio API (openapi) a recipe (jsonld) an article (jsonld) a storefront (shopify)
// Paste a URL and click Get tools.

Shopper-side MCP vs. owner-side admin tools.

Most existing "AI for e-commerce" tools target the merchant. wmcp.sh targets the shopper — public storefronts, no admin credentials, every store.

Capability Shopify dev-mcp Composio wmcp.sh
Built for Merchants & devs (owner) Enterprise integrations (owner) AI shopping agents (shopper)
API surface Admin API + GraphQL Admin APIs + webhooks Storefront + JSON-LD + LLM
Auth required Yes — admin token Yes — OAuth / API key No — public endpoints
Stores covered The one you connect Each user connects each one All 4M+ Shopify stores + JSON-LD retailers
Transactional tools Docs + schema lookup CRUD on the store you own get_price · check_stock · add_to_cart
OpenAPI → tools Partial any 3.x / Swagger 2.0 spec
Cache Per-store realtime Proxy latency Shared global · <100ms hits

What it looks like from your agent's side.

An LLM gets the tools, decides which to call, and the call returns real data. That's the whole loop — no per-site adapter code in your app.

Drop-in for any agent framework.

The schema is MCP-shaped, so your agent doesn't care whether it's Shopify or JSON-LD under the hood. You ship the URL — wmcp.sh ships the tools.

  • Static tools like get_price return immediately
  • Live actions like add_to_cart hit real endpoints
  • Cached schemas serve in under 100ms
  • Headers tell you your remaining quota

One line of config — or three lines of code.

Connect wmcp.sh as a native MCP server, or call the REST API from any framework. Copy. Done.

// wmcp.sh is a real MCP server — add it to Claude Code / Cursor / Codex / VS Code.
{
  "mcpServers": {
    "wmcp": {
      "type": "http",
      "url": "https://wmcp.sh/mcp/u/<base64url-of-your-url>"
    }
  }
}
// One site → /mcp/u/<b64url>   ·   compose many → /mcp/url?url=a&url=b
// tools/list is free; live tools/call uses your Bearer key.
curl 'https://wmcp.sh/api/v1/tools?url=https://www.allbirds.com/products/mens-wool-runners'
// Plain fetch — works everywhere.
const r = await fetch(
  `https://wmcp.sh/api/v1/tools?url=${encodeURIComponent(url)}`,
  { headers: { authorization: `Bearer ${API_KEY}` } }
);
const { tools } = await r.json();
// Pass wmcp tools straight into Anthropic SDK.
const tools = (await fetch(`https://wmcp.sh/api/v1/tools?url=${url}`).then(r => r.json())).tools;
const msg = await anthropic.messages.create({
  model: "claude-opus-4-8",
  tools: tools.map(t => ({
    name: t.name,
    description: t.description,
    input_schema: t.inputSchema || { type: "object" }
  })),
  messages: [{ role: "user", content: "Add the size 10 to my cart." }]
});
# LangChain — wrap each wmcp tool as a StructuredTool.
from langchain.tools import StructuredTool
import requests

data = requests.get(f"https://wmcp.sh/api/v1/tools?url={url}").json()
tools = [
  StructuredTool.from_function(
    func=lambda args, t=t: call_wmcp(t["name"], args, url),
    name=t["name"],
    description=t["description"],
  )
  for t in data["tools"]
]
// OpenAI function-calling format.
const { tools } = await (await fetch(`https://wmcp.sh/api/v1/tools?url=${url}`)).json();
const completion = await openai.chat.completions.create({
  model: "gpt-4o",
  tools: tools.map(t => ({
    type: "function",
    function: {
      name: t.name,
      description: t.description,
      parameters: t.inputSchema || { type: "object", properties: {} }
    }
  })),
  messages: [{ role: "user", content: "Find the cheapest variant." }]
});

Free to try. Paid to scale.

Every plan includes the open-source adapters and the shared cache. Paid unlocks live execute + higher quotas.

Free

$0/mo
  • 100 reads / day
  • 50 cache pushes / day
  • No live execute
  • Best-effort cache
Use anonymously →

Pro

$99/mo
  • 10,000 reads / day
  • 5,000 cache pushes / day
  • 1,000 live executes / day
  • Shopify add_to_cart
  • Priority cache freshness

Reseller

$299/mo
  • 100,000 reads / day
  • 50,000 executes / day
  • Restock webhooks (coming)
  • Headless tier (coming)
  • Email support
Continue to checkout

Enter your email — your API key is tied to it so you can recover it anytime. No password.

mcp://constellation — live

It gets faster the more people use it.

  1. You hit a URL. If we've seen it, you get cached tools in <100ms.
  2. If not, an adapter runs. Shopify, JSON-LD, or — for protected sites — the Chrome extension extracts client-side.
  3. The schema gets pushed back to the shared cache. Next person who asks gets it instantly. Without ever installing anything.

Every install of the extension makes the hosted API better for everyone — including users who never install it. See what's already cached →

Frequently asked questions

What we get asked most. Schema-marked-up so Google can show these as rich snippets.

How does wmcp.sh differ from Shopify's AI Toolkit (dev-mcp)?
Shopify's dev-mcp is owner-side — it connects to the Shopify Admin API for store management and requires admin credentials. wmcp.sh is shopper-side — it operates on public storefronts using Shopify's storefront JSON, schema.org JSON-LD, or an LLM fallback, so AI shopping agents can fetch prices, list variants, and trigger add_to_cart without merchant credentials.
How does wmcp.sh differ from Composio?
Composio is an enterprise integration proxy aimed at owner-side admin APIs (Stripe, GitHub, Slack, Shopify Admin). wmcp.sh is purpose-built for shopper-side transactional flows — product lookup, variant comparison, add_to_cart — and caches schemas in a shared global cache that serves under 100ms. wmcp.sh also ingests any OpenAPI spec; Composio handles each integration separately.
Can wmcp.sh turn an OpenAPI spec into MCP tools?
Yes. Hand any JSON OpenAPI 3.x or Swagger 2.0 spec URL to wmcp.sh and the adapter walks every path × method, resolves $refs against #/components/schemas/, and emits a typed tool list ready for Claude tool_use, OpenAI function-calling, or LangChain. Try it:
curl 'https://wmcp.sh/api/v1/tools?url=https://petstore3.swagger.io/api/v3/openapi.json'
Which AI agent frameworks does wmcp.sh work with?
Drop-in SDKs for Anthropic SDK (Claude tool_use), OpenAI (function-calling), LangChain (StructuredTool), and Vercel AI SDK. Install: pip install wmcp or npm install @wmcp/sdk. Anything else that consumes MCP-shaped tools — Cursor, Cline, Claude Code, Gemini CLI — works directly with the public REST API.
What happens when a site blocks bot traffic?
Sites behind Akamai or Incapsula (Amazon, Nike) block server-side fetches. For these, the wmcp.sh Chrome extension extracts schemas client-side in your real browser and pushes them back to the shared cache. The next time anyone — any user, any agent — asks wmcp.sh for that URL, the cached schema is served server-side instantly.
W

Why this exists. LLM agents can talk to ChatGPT but not to Allbirds. Every framework reinvents per-site scrapers and the same Shopify cart endpoint gets rediscovered weekly. wmcp.sh is the open layer that solves it once.

Built in the open. Adapters are MIT-licensed. PRs accepted. Last updated 2026-05-27. github.com/New1Direction/webmcp-anything · directory