How do I install Shopgraph?

Shopgraph supports both local and remote installation. For local use, install it via npm (npx) and add the configuration to your AI app. For remote access, add the server URL to your MCP configuration.

Is Shopgraph safe to use?

Shopgraph scored 6/10 (moderate risk) in MCP Marketplace's automated security scan. It has 3 high or critical findings to review. It's listed, but review the security report on this page before installing.

What credentials does Shopgraph need?

Shopgraph requires the following credentials or environment variables: payment_method_id, strict_confidence_threshold, format. You can find setup instructions on the server detail page.

What AI apps work with Shopgraph?

Shopgraph uses the Model Context Protocol (MCP) and works with any MCP-compatible AI app, including Claude, ChatGPT / Codex, Gemini, Copilot, Cursor, and more.

Back to Browse

Shopgraph MCP Server

by Krishna Brown

Developer ToolsModerate6.0LocalRemote

Free

The extraction API that shows its work.

About

ShopGraph extracts product data from any URL and shows you exactly how each field was derived. Per-field provenance and confidence based on extraction method, not opinion. Your automation decides what's reliable enough to act on.

Hosted remote MCP server at `https://shopgraph.dev/mcp`. 50 free calls per month, no signup. Paid usage via API key (`sg_live_…`) or pay-per-call via Stripe MPP.

Security Report

6.0

Moderate6.0Moderate Risk

Valid MCP server (2 strong, 1 medium validity signals). 3 known CVEs in dependencies (1 critical, 2 high severity) Package registry verified. Imported from the Official MCP Registry.

6 files analyzed · 4 issues found

Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.

Permissions Required

This plugin requests these system permissions. Most are normal for its category.

env_vars

Check that this permission is expected for this type of plugin.

database

Check that this permission is expected for this type of plugin.

What You'll Need

Set these up before or after installing:

Stripe payment method ID for pay-per-call agent usage via Stripe MPP. Get one from your Stripe account at Free tier works without this.Optional

Environment variable: payment_method_id

Number between 0 and 1. Fields with per-field confidence below this are omitted from the response server-side. Useful for autonomous agents that should never act on low-confidence data.Optional

Environment variable: strict_confidence_threshold

Set to `ucp` for Universal Commerce Protocol output (validated against the [`ucp-schema` v1.1.0]() validator). Default returns ShopGraph's native JSON shape.Optional

Environment variable: format

How to Install & Connect

Available as Local & Remote

This plugin can run on your machine or connect to a hosted endpoint. during install.

Getting Started

Once installed, try these example prompts and explore these capabilities:

1"Get me the price, availability, and brand for https://www.allbirds.com/products/mens-tree-runners"
2"Extract structured data from this product URL and only return fields with confidence above 0.8"
3"Return the UCP-compatible output for this URL so my agent can consume it"
4Tool: `enrich_product` — Full extraction pipeline with per-field confidence and provenance. Use when you need reliable product data from any retailer URL.
5Tool: `enrich_basic` — Schema.org-only extraction. Use when the site has good structured data and you want the fastest, cheapest path.
6Tool: `enrich_html` — Bring your own HTML. Use when you've already fetched the page via another tool (Bright Data, Firecrawl, a headless browser) and just need structuring.

Documentation

View on GitHub

From the project's GitHub README.

ShopGraph

The extraction API that shows its work. Send a URL or raw HTML, get structured JSON with per-field confidence scoring and extraction provenance — every field shows which method produced it (Schema.org, LLM inference, or headless browser) and how confident the system is. Set strict_confidence_threshold and uncertain fields are removed server-side before they reach your agent. 50 free calls/month.

Website: https://shopgraph.dev | API: https://shopgraph.dev/api/enrich/basic | MCP: https://shopgraph.dev/mcp

UCP output validated with ucp-schema v1.1.0 — the official Universal Commerce Protocol schema validator.

Quick Start

# Free — no API key, no signup
curl -X POST https://shopgraph.dev/api/enrich/basic \
  -H "Content-Type: application/json" \
  -d '{"url": "https://www.allbirds.com/products/mens-tree-runners"}'

Returns structured JSON with per-field confidence scores:

{
  "product": {
    "product_name": "Men's Tree Runners",
    "brand": "Allbirds",
    "price": { "amount": 100, "currency": "USD" },
    "availability": "in_stock",
    "categories": ["Shoes", "Running"],
    "confidence": { "overall": 0.95 },
    "_shopgraph": {
      "field_confidence": {
        "product_name": 0.97,
        "brand": 0.95,
        "price": 0.98,
        "availability": 0.90
      }
    }
  },
  "free_tier": { "used": 1, "limit": 50 }
}

Tools / Endpoints

Tool	REST Endpoint	Price	What It Does
`enrich_basic`	`POST /api/enrich/basic`	Free (shared quota)	Schema.org extraction only. Fast, zero LLM cost.
`enrich_product`	`POST /api/enrich`	Free 50/mo, then subscription or $0.02/call	Full pipeline with per-field confidence scoring and extraction provenance.
`enrich_html`	`POST /api/enrich/html`	Subscription or $0.02/call	Bring your own HTML. Works with Bright Data, Firecrawl, or any fetch/proxy tool.

Pricing: Free (50/mo) | Starter $99/mo (10K calls) | Growth $299/mo (50K calls) | Enterprise (custom). Pay-per-call via Stripe MPP still available for agents. Cached results (24h) are free. No charge for failed extractions.

How It Works

Your agent sends a URL (or raw HTML)
  → Tier 1: Schema.org/JSON-LD parsing (0.93 baseline confidence, instant)
  → Tier 2: LLM extracts from page text when structured data is absent (0.70 baseline)
  → Tier 3: Headless Playwright renders JavaScript, then extracts (additional inference step)
  → Returns ProductData with per-field confidence scores and extraction provenance
    (which tier produced each field) in _shopgraph.field_confidence
  → Set strict_confidence_threshold to remove low-confidence fields server-side
    before they reach your agent
  → Add format=ucp for Universal Commerce Protocol output

Authentication: API key (sg_live_ keys) for subscription tiers, or Stripe MPP for pay-per-call agents.

ShopGraph is a structuring layer, not a fetcher. It's complementary to Bright Data, Firecrawl, and other fetch/proxy tools. They handle retrieval. ShopGraph handles extraction provenance and per-field confidence scoring.

REST API

`POST /api/enrich/basic` (Free tier)

curl -X POST https://shopgraph.dev/api/enrich/basic \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/product"}'

Schema.org only. Shares the free-tier quota with /api/enrich. No signup needed.

`POST /api/enrich` (Full extraction)

# With API key (subscription)
curl -X POST https://shopgraph.dev/api/enrich \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sg_live_..." \
  -d '{"url": "https://example.com/product", "strict_confidence_threshold": 0.8, "format": "ucp"}'

# With Stripe MPP (pay-per-call)
curl -X POST https://shopgraph.dev/api/enrich \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/product", "payment_method_id": "pm_..."}'

Full pipeline: Schema.org → LLM inference → headless browser. 50 free calls/month. Authenticate with API key (sg_live_) or Stripe MPP for higher limits.

`POST /api/enrich/html` (Bring your own HTML)

curl -X POST https://shopgraph.dev/api/enrich/html \
  -H "Content-Type: application/json" \
  -d '{"html": "<html>...</html>", "url": "https://example.com/product", "payment_method_id": "pm_..."}'

Already fetched the page? Pipe the HTML to ShopGraph for structuring.

MCP Configuration

{
  "mcpServers": {
    "shopgraph": {
      "type": "url",
      "url": "https://shopgraph.dev/mcp"
    }
  }
}

Works with Claude, Claude Code, Cursor, Windsurf, CrewAI, LangGraph, AutoGen, and any MCP client.

Extracted Data

Every response includes:

Field	Description
`product_name`	Product title
`brand`	Manufacturer or brand
`price`	Amount + currency + sale price
`availability`	`in_stock`, `out_of_stock`, `preorder`, `unknown`
`categories`	Product taxonomy
`image_urls`	Product images (enrich_product/enrich_html only)
`color`	Available colors
`material`	Materials/fabrics
`dimensions`	Size/weight info
`confidence`	Overall + per-field scores (0-1)
`_shopgraph.field_confidence`	Per-field confidence with field-type modifiers

Self-Hosted Setup

git clone https://github.com/laundromatic/shopgraph.git
cd shopgraph
npm install

Required .env:

Variable	Purpose
`STRIPE_TEST_SECRET_KEY`	Stripe secret key (test or live)
`GOOGLE_API_KEY`	Gemini API key for Tier 2 (LLM) inference
`UPSTASH_REDIS_REST_URL`	Upstash Redis for stats/monitoring (optional)
`UPSTASH_REDIS_REST_TOKEN`	Upstash Redis token (optional)

npm run build          # Compile TypeScript
npm start              # Run MCP server (stdio)
npm run start:http     # Run HTTP server
npm run dev            # Dev mode (no build needed)
npm run test:run       # Run 118 tests

Monitoring

ShopGraph runs 118 automated tests across 22 product verticals. Self-healing pipeline with circuit breaker, URL verification, and health alerts.

Health: https://shopgraph.dev/health
Stats: https://shopgraph.dev/api/stats
Dashboard: Live on shopgraph.dev homepage

License

Apache 2.0

Built By

Krishna Brown | Los Angeles, CA

Reviews

No reviews yet

Be the first to review this server!

installs

New

no ratings yet

Uptime

Operational

30-day uptime100%

Avg latency (24h)187ms

Last checked03:45 AM

Use Cases

Per-field confidence scoring (0–1) on every extracted field
Extraction provenance: every field labeled with the method that produced it (Schema.org
LLM
or headless browser)
Server-side confidence gating via `strict_confidence_threshold` — uncertain fields never reach your agent
UCP (Universal Commerce Protocol) output format for agent interoperability
Three-tier extraction pipeline: Schema.org/JSON-LD → LLM inference → headless Playwright
Works on any product URL across retailers
DTC brands
and B2B suppliers
Bring-your-own-HTML mode for use with Bright Data
Firecrawl
or any fetch/proxy tool
Zero-signup free tier (50 calls/month
IP-based)
Pay-per-call via Stripe Machine Payments Protocol — agents authenticate with a payment method instead of an API key
24-hour caching on successful extractions (cached results are free)
No charge on failed extractions